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

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 3

你的实现（第二个循环）是不对的，它将不能简单的测试用例：输入＆gt; 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 4

您可以按照以下方法删除这些不需要的零，但在这种情况下，它会被排序。

@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 + ",");
    }
}

Answer 5

如果你想在课堂上听起来非常聪明，请指出这是一种比Java更高效的语言中的单行：）

Java从数组中删除零

5 个答案: