返回排序数组中唯一数字的数量[重复]答案

【问题标题】：Returning the number of unique numbers in a sorted array [duplicate]返回排序数组中唯一数字的数量[重复]
【发布时间】：2016-01-01 15:22:59
【问题描述】：

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

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

这是我的方法：

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。

我做错了什么？

【问题讨论】：

@TimBiegeleisen 我不能使用该方法，因为我不允许使用嵌套循环，并且数组中的任何元素最多只能移动一次。
你不能直接返回j + 1吗？这就是您设置 k = j + 1 以添加零时所做的事情。
您正在使用j 保留最后一个唯一编号的索引。所以唯一数字的计数是j + 1。最后返回j + 1。
@JonnyHenly 如果我返回 (j+1)，返回的值仍然是错误的，不等于唯一元素的数量。
您说它返回 9 但应该返回 10，9 + 1 = 的 10。这只是您提供给我们的示例数组，具有重复项的数组在前后是什么样子的？

标签： java arrays return return-value

【解决方案1】：

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

在数组中，i'th 索引实际上是从 1 开始计数的第 i + 1'th 元素。

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

【讨论】：

【解决方案2】：

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

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 进行了测试，并且似乎可以正常工作。

【讨论】：

@RockAndaHardPlace 请查看此答案，谢谢。
这确实可以删除重复项并放置 0，但它不会返回唯一元素的数量。
理论上，这应该有效，就像@Lahiru 的答案应该有效一样，但对我来说它仍然返回错误的值。虽然这可能是因为一个不相关的问题。还是谢谢！
您的代码有很多问题。您是否希望我从您的代码开始并尝试回答？
当然，如果你愿意，@Tim！

【解决方案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 }

【讨论】：

【解决方案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;
}

【讨论】：