Question

我正在为我的Data Structures类解决Java问题。

基本上，我们应该采用排序数组，从中删除任何重复数据，然后将这些唯一值复制到新数组中。然而，具有挑战性的一点是我们只允许迭代一次数组。我遇到的每个解决方案都需要至少两次遍历数组：一次用于＆＃34;删除＆＃34;重复值，以及另一次将唯一值复制到新数组。

在识别唯一值的过程中，有什么方法可以将唯一值复制到新数组中吗？我正在撞墙，遇到各种各样的OutOfBounds异常，试图弄清楚这一点。

我还应该提到数组的大小被认为是给定的。

感谢阅读！

到目前为止，这是我创建新数组的代码：

public static double[] removeDuplicates (double[] list) {

        int numOfUniques = numUnique(list);
        if (numOfUniques == 0){
            return null;
        }
        else if (list.length < 2){
            return list;
        }

        int counter = 0;
        double[] uniquesArray = new double[numOfUniques];
        uniquesArray[0] = list[0];

        for(int i = 0; i < list.length-1; i++){
            if (list[i] == list[counter]){
                continue;
            }
            else{
                counter++;
                uniquesArray[counter] = list[i];
            }   
        }

      return uniquesArray;
}

对于值为{10,11,12}的数组，这已返回值为{10,11,0}的数组

Answer 1

在（List的迭代过程中）将值添加到Set，然后从此List创建Set。 Set仅接受唯一值 - 重复项始终被丢弃。

Answer 2

由于它是一个数据结构类，我认为你只需要使用数组，试试这个：

public double[] getUniqueItems (double[] array){
        double[] unique = new double[array.length];
        Arrays.sort(array);

        double currentItem = array[0];
        unique[0] = currentItem;

        for(int i = 1; i<array.length;i++){
            if(array[i] != currentItem){
                unique[i] = array[i];
                currentItem = array[i];
            }
        }

        return unique;
    }

Answer 3

不确定是否允许你的作业，但你可以用Java 8 oneliner（根本没有循环）做你想做的事情：

    double[] dA = ..... // your input array
    Arrays.sort(dA);    // sort it
    double[] dB = IntStream.range(0, dA.length)
                    .mapToDouble(i -> dA[i]).distinct().toArray();

编辑：正如波希米亚人所指出的，这可以缩短为：

    double[] dB = DoubleStream.of(dA).distinct().toArray();

Answer 4

感谢所有伟大的回应，加尔斯和家伙们！我考虑了你们每个人所说的很多东西，我相信我已经解决了问题。这是我的解决方案（numUnique是一个返回排序数组中唯一项数的函数）：

public static double [] removeDuplicates（double [] list）{

    int numOfUniques = numUnique(list);
    if (numOfUniques == 0){
        return null;
    }
    else if (list.length < 2){
        return list;
    }


    double[] unique = new double[numOfUniques];
    double currentItem = list[0];
    unique[0] = currentItem;
    int j = 1;

    for (int i = 1; i < list.length; i++){
        if (currentItem != list[i]){
            unique[j] = list[i];
            currentItem = list[i];
            j++;
        }
    }

    return unique;
}

Answer 5

JDK提供了一个简单的（尽管是O（n）空间复杂度）解决方案，只使用一次传递：

return DoubleStream.of(input).distinct().toArray();

如果您需要推送自己的实现，请考虑因为输入已排序，您只需要将不同的元素保留到前一个元素（加上第一个元素）。

一个实现可能是：

double[] input; // given this
int count = 0;
for (int i = 0; i < input.length; i++) {
    if (i > 0 && input[i] != input[i-1])
        count++;
    input[count] = input[i];
}
return Arrays.copyOf(input, count);

这使用结果数组的就地构建，因此仅使用O（1）空间。

将已排序数组中的唯一值复制到新数组***

5 个答案: