2、数组中重复的数字

题目描述

在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

思路：

解法一：查找一个数组中第一个重复的数字，可以使用暴力破解法，时间复杂度为O(n*2)，迭代数组中的每个数字，然后判断其是否与其之后的数字重复。

 

（解法二错了，但是通过了牛客网的用例测试）

解法二：暴力破解法在没有条件 “在一个长度为n的数组里的所有数字都在0到n-1的范围内” 的情况下是适用的，现在题目多了这个条件，说明提供了更多的信息 （数组内的数字的范围在0~n-1之间），该如何利用这个信息呢？

将数字与数组的位置信息结合，两者的范围都是0~n-1，

1）迭代数组中的每个元素，判断其是否与其所在位置的索引（即i）相等，

      2）相等的话，迭代下一个元素；

      3）不同的话，判断位置numbers[i]上的元素 numbers[numbers[i]] 是否与其所在位置的索引（即numbers[i]）相等

            4）如果相等，说明位置i和位置numbers[i]上的元素重复，返回true

            5）如果不相等，则将位置i和位置numbers[i]上的元素交换，结果使得位置numbers[i]的索引与其元素相等

6）迭代结束，每次迭代，都能确保一个位置的索引与该位置上的元素大小相等，如果迭代结束都没有找到重复元素，说明没有重复元素，返回false

 

class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        //判断输入是否有效
        if(length <= 0)
            return false;

        for(int i = 0; i < length; i++){
            //如果数组中的数字不在范围[0, length)内，返回false
            if(numbers[i] < 0 || numbers[i] > length - 1)
                return false;
                       
            //判断位置i上的数字是否等于i
            if(numbers[i] != i){
                //如果位置i上的数字不等于i，然后判断位置numbers[i]上的数字是否等于numbers[i]
                if(numbers[i] != numbers[numbers[i]]){
                    //如果位置i上的数字numbers[i]不等于i，且位置numbers[i]上的数字
                    //numbers[numbers[i]]不等于numbers[i],交换位置i和位置numbers[i]
                    //上的数字,这样会使得位置numbers[i]上的数字等于numbers[i]
                    int tmp = numbers[i];
                    numbers[i] = numbers[numbers[i]];
                    numbers[tmp] = tmp;
                }
                //如果位置i上的数字numbers[i]不等于i，而位置numbers[i]上的数字
                //numbers[numbers[i]]等于numbers[i]，则说明位置i上的数字和位置
                //numbers[i]上的数字重复
                else{
                    *duplication = numbers[i];
                    return true;
                }
            }
            
            //如果位置i上的数字等于位置i，则循环到下一个位置
        }
        
        //没有重复
        return false;
    }
};

解法二通过了牛客网的用力测试，但是，思考后发现，它不能通过用例{0, 3, 2, 2, 4}的测试

按照解法二的思路，

错误之处在于：

//如果位置i上的数字numbers[i]不等于i，且位置numbers[i]上的数字
                    //numbers[numbers[i]]不等于numbers[i],交换位置i和位置numbers[i]
                    //上的数字,这样会使得位置numbers[i]上的数字等于numbers[i]

然后接着 i++ ，迭代下一个元素，但是位置 i 上的元素不一定等于 i，比如这里，交换后，位置1的元素为2，不相等。

 

正确的做法是：

链接：https://www.nowcoder.com/questionTerminal/623a5ac0ea5b4e5f95552655361ae0a8
来源：牛客网
 

• 把当前序列当成是一个下标和下标对应值是相同的数组；
• 遍历数组，判断当前位的值和下标是否相等： 2.1. 若相等，则遍历下一位； 2.2. 若不等，则将当前位置i上的元素和a[i]位置上的元素比较：若它们相等，则成功！若不等，则将它们两交换。换完之后a[i]位置上的值和它的下标是对应的，但i位置上的元素和下标并不一定对应；重复2.2的操作，直到当前位置i的值也为i，将i向后移一位，再重复2.

​
class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        //非法输入
        if(numbers == NULL || length <= 0)
            return false;
        
        //非法输入
        for(int i = 0; i < length; i++){
            if(numbers[i] < 0 || numbers[i] >= length)
                return false;
        }
        
        //数组中的数字的范围在[0, n),如果不重复，可以通过两两交换使得每个值与其索引位置值相同
        //如果存在重复，则存在某个索引值，数组中找不到与其相等的值
        for(int i = 0; i < length; i++){
            while(numbers[i] != i){
                if(numbers[i] == numbers[numbers[i]]){
                    *duplication = numbers[i];
                    return true;
                }
                else{
                    int tmp = numbers[i];
                    numbers[i] = numbers[numbers[i]];
                    numbers[tmp] = tmp;
                }
            }
        }
        return false;       
    }
};

​

 

解法三：

哈希法

1. 由于所有元素值是有范围的，因此可以用一个长度为n的数组，下标表示序列中的每一个值，下标对应的值表示该下标出现的次数。
2. 只需扫描一次原序列，就统计出所有元素出现的次数；
3. 再扫描一次哈希数组，找到一个出现次数大于1的值即可。

这种方法时间复杂度和空间复杂度都为O(n)。链接：https://www.nowcoder.com/questionTerminal/623a5ac0ea5b4e5f95552655361ae0a8
来源：牛客网
 

class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        int* num = new int[length];  
        //创建一个长度为length的数组，全部赋值为0
        for(int i = 0; i < length; i++)
            num[i] = 0;
        
        //迭代数组numbers，统计每个数字出现的次数，存放在数组num中
        for(int i = 0; i < length; i++)
            num[numbers[i]]++;
        
        for(int i = 0; i < length; i++)
            if(num[numbers[i]] > 1){
                *duplication = numbers[i];
                delete []num;
                return true;
            }
        delete []num;
        return false;                
    }
};