Question

我被要求编写一个接受排序数组的方法，删除在数组中找到的所有重复元素，然后在找到的每个重复元素的数组末尾放置一个0。

它还应该返回数组中找到的唯一元素的数量。

这是我的方法：

public static int removeDups(int[] arr) {
    int j = 0;
    int i = 1;
    int numDups = 0;

    while(i < arr.length) {
        if (arr[i] == arr[j]) {
            i++;     
            numDups++;       
        } 
        else {
            arr[++j] = arr[i++];
        }   
    }

    for (int k = j+1; k < arr.length; k++) {
        arr[k] = 0;     
    }

    return (j); 
}

它成功找到数组中的所有重复数字，并在末尾放置正确数量的0，但它并不总是为唯一元素的数量返回正确的值。

例如，对于数组：

{ 6 10 19 21 23 26 27 36 38 45 }

唯一元素的数量应为10，但它返回9.

我做错了什么？

Answer 1

这是您的问题的解决方案。它跟踪两个指针，一个只在值写入到数组时前进，另一个按顺序接触数组的每个元素。当遇到一个或多个重复项时，第二个指针继续前进，而第一个指针保持不变，等待写入非重复值。最后，代码从第一个指针迭代数组的其余部分，写出零直到结束。

public static int removeDups(int[] arr) {
    if (arr == null) {
        return null;
    }

    if (arr.length == 0 || arr.length == 1) {
        return arr;
    }

    int prevIndex = 0;

    for (int i=1; i < arr.length; ++i) {
        if (arr[prevIndex] != arr[i]) {
            arr[prevIndex+1] = arr[i];
            ++prevIndex;
        }
    }

    for (int i=prevIndex+1; i < arr.length; ++i) {
        arr[i] = 0;
    }

    return prevIndex+1;
}

int[] arr = {1, 2, 3, 3, 4, 5, 6, 6, 6, 10};
removeDups(arr);
System.out.println(Arrays.toString(arr));

<强>输出：

[1, 2, 3, 4, 5, 6, 10, 0, 0, 0]

此代码已使用IntelliJ进行测试，似乎正在运行。

Answer 2

可以看出，j被用作最后一个唯一元素的索引。

在数组中，i＆＃39;索引实际上是从{1开始计算的i + 1＆＃39;元素。

因此，您必须从方法中返回j + 1而不是j。

Answer 3

试试这个！

static int getUniqueElements(int [] sortedArr){

        int duplicateCount = 0;
        int [] tempArr = sortedArr;
        int j=0;
        boolean isNewValue = true;
        for(int i=1;i<tempArr.length;i++){
            if(sortedArr[j] != tempArr[i]){
                isNewValue = true;
                sortedArr[++j] = tempArr[i];
            }else{
                if(isNewValue){
                    isNewValue = false;
                    duplicateCount++;
                }
            }
        }

        for(j++;j<sortedArr.length;j++){
            sortedArr[j] = 0;
            duplicateCount++;
        }

        return (sortedArr.length-duplicateCount);

    }
    public static void main(String[] args) {
        int[] arr = {1, 3, 3, 3, 3, 6, 6, 7, 8, 8};
        System.out.println("Unique Count:"+ getUniqueElements(arr));
        System.out.println(Arrays.toString(arr));
    }

输出：

Unique Count:2
[1, 3, 6, 7, 8, 0, 0, 0, 0, 0]

因为在给定的数组中1,7是唯一的。

注意 ：尝试使用示例数组{6, 10, 19, 21, 23 ,26 ,27 ,36 ,38, 45 }

Answer 4

我的解决方案是（假设元素只能重复两次）：

public static int removeDups(int[] arr) {       
    int i = 0;
    int numDups = 0;
    while (i < arr.length - 1 - numDups) {          
        if (arr[i] == arr[i + 1]) {
            numDups++;
            for (int m = i + 1; m < arr.length - numDups; m++) {
                arr[m] = arr[m + 1];
            }
            arr[arr.length - numDups] = 0;
        }           
        i++;
    }
    return arr.length-numDups;
}

返回已排序数组中的唯一数字的数量

4 个答案: