Java удаляет нули из массива

Question

Я пытаюсь написать программу, которая при выполнении будет проходить через массив и удалять все экземпляры 0.0, изменять размер массива, равный количеству ненулевых элементов, и помещать эти элементы в их прежнем порядке.,То есть, если n = 10 и содержимое a [j], j = от 0 до n - 1 изначально равно

0.0, 1.2, 0.0, 0.0, 0.0, 2.3, 0.0, 9.7, 5.6, 0.0

, то после выполнения кода содержимое должно быть

 n=4, a[0]=1.2, a[1]=2.3, a[2]=9.7, and a[3]=5.6.

Это то, что я имею до сих пор:

import java.util.Scanner;
public class hw2
{
   public static void main(String[] args) 
   {
       Scanner scan = new Scanner(System.in);
       final double KEY = 0.0;
       int n = scan.nextInt();
       double[] a = new double[n];
       for(int i=0; i<n; i++)
       {
           a[i] = scan.nextDouble();
       }
       for(int k = 0; k<n; k++)
       {
           if(a[k] == KEY)
           {
               a[k] = a[k+1];
               n--;
           }
           System.out.println(a[k]);
       }
   }
}

Хотелось бы лишь слегка подтолкнуть его в правильном направлении.

Answer 1

Подумайте об использовании ArrayList , который позволит вам добавлять элементы по мере необходимости, увеличивать их по мере необходимости и поддерживать точный счет.

Хотя в этом случае, если вы хотели /необходимо использовать массив, вы можете просто не сохранять значение, если это «0», возможно.(Также не увеличивайте «переменную используемого массива», кроме случаев, когда вы добавляете, так что вы знаете, сколько содержит данных «не 0», или обрабатываете первые «0», встретившиеся во время итерации, как «конец полезных данных» -инициализируется значением по умолчанию типа.)

Если вы хотите перейти от массива с нулями к массиву без нулей вообще, вы должны использовать два прохода - один для подсчета ненулей,создать новый массив соответствующего размера, а затем скопировать ненулевые значения.Это может быть сделано и в обратном порядке (сжатие исходного массива, а затем копирование его «заполненной» части), но это немного сложнее.

Если вы продолжите свой текущий подход (которыймассив результатов будет иметь нули, но в конце) вам нужно поддерживать два указателя индекса - один - итератор основного цикла, второй - следующее место для установки ненулевого значения, который увеличивается только тогда, когда значение копируется (или не перемещается, например, когда оба индекса одинаковы, что будет иметь место до тех пор, пока не встретится первый 0).Удостоверьтесь, что вы обнулили место, из которого вы переместили ненулевое значение.Количество ходов можно уменьшить, если порядок не требуется сохранять.

Answer 2

Ваша реализация (вторая для цикла) не верна, она не сможет выполнить простой тестовый пример: Ввод> 5 2,0 2 0,0 3 0,0 Ваша программа будет иметь неправильный вывод: 2,0 2,0 3.0 3,0 * * тысяча одна

но должно быть 2,0 2,0 3

Кроме того, вы не можете использовать == для сравнения двух двойных.

Следующий код - мое решение, основанное на вашем текущем коде:

    public class hw21 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        final double KEY = 0.0;
        final Double ACCEPTABLE_TOLERANCE = 0.000000000001d;

        int n = scan.nextInt();
        double[] a = new double[n];
        for (int i = 0; i < n; i++) {
            a[i] = scan.nextDouble();
        }
        for (int k = 0, j = 0; k < n; k++) {
            if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) {
                continue;
            }
            a[j] = a[k];
            System.out.println(a[j]);
            j++;
        }
    }
}

Также я предпочитаю использовать ArrayList, как показано ниже:

public class hw2 {
public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    final double KEY = 0.0;
    final Double ACCEPTABLE_TOLERANCE = 0.000000000001d;

    int n = scan.nextInt();
    double[] a = new double[n];
    for (int i = 0; i < n; i++) {
        a[i] = scan.nextDouble();
    }

    List<Double> newList = new ArrayList<Double>();
    for (int k = 0; k < n; k++) {
        if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) {
            continue;
        }
        newList.add(a[k]);
    }

    System.out.println("There are " + newList.size() + " no-zero double:");
        System.out.println(newList);
    }
}

Answer 3

import java.util.Arrays;
import java.util.Scanner;

public class StackOverflow1
{
    public static final double KEY = 0.0;
    private static final Scanner INPUT = new Scanner(System.in);

    public static void main(String[] args) {


       int length = INPUT.nextInt();
       double[] array = new double[length];

       for(int i=0; i<length; i++) {
           array[i] = INPUT.nextDouble();
       }

       int index = 0;
       for(int k = 0; k < length ; k++) {
           if(array[k] == KEY) {
               continue;
           }
           array[index] = array[k]; // bring the non-zeroth element forward
           if (index != k) array[k] = 0; //make the non-zeroth element zero in the actual location
           index++;
       }
       System.out.println("n = " + index + " array = " + Arrays.toString(array));
   }
}

Answer 4

Если вы хотите звучать по-настоящему умно в классе, отметьте, что это один вкладыш во многих языках, более производительных, чем Java:)

Answer 5

вы можете удалить эти ненужные нули следующим образом, но в этом случае они сортируются.

@org.junit.Test
public void test15() throws Exception {
    double[] arr = new double[]{0.0,1.1,0.1,0.0,2.1};
    double[] nonZeroArr = arr;

    Arrays.sort(nonZeroArr);
    int index = -1;
    while((index = Arrays.binarySearch(nonZeroArr, 0.0)) > -1){
        double[] newArr = new double[nonZeroArr.length-index-1];
        System.arraycopy(nonZeroArr, index+1, newArr, 0, newArr.length);
        nonZeroArr = newArr;
    }
    for (double d : arr) {
        System.out.print(d +",");
    }
    System.out.println();
    for (double d : nonZeroArr) {
        System.out.print(d + ",");
    }
}