剑指 Offer 03. 数组中重复的数字

逃离我推掉我的手 2022-09-11 05:22 190阅读 0赞

# **⭐️**题目一描述**⭐️** #

> 找出数组中重复的数字。
> 
> 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

**示例 1：**

> 输入：  
> \[2, 3, 1, 0, 2, 5, 3\]  
> 输出：2 或 3

**限制：**

> `2 <= n <= 100000`

【**来源**】力扣（LeetCode）

【**链接**】[https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/][https_leetcode-cn.com_problems_shu-zu-zhong-zhong-fu-de-shu-zi-lcof]

## **⭐️解题思路⭐️** ##

### 解法1 — 穷举法 ###

最简单的办法就是遍历数组的每个元素，然后将当前访问的数组与剩余的数组元素作大小比较，如果遇到相等的，则说明这个元素的值重复了，直接返回结果；如果不等，则继续遍历下一个数组元素。

### 【算法描述】C语言实现 ###

int findRepeatNumber(int* nums, int numsSize){
        if(nums == NULL || numsSize <= 0)
            return -1;
        
        for(int i=0; i<numsSize; i++){
            for(int j=i+1; j<numsSize; j++){
                if(nums[i] == nums[j])
                    return nums[i];
            }
        }
        return -1;
    }

### 【**算法复杂度**】 ###

**空间复杂度**：没有开辟新的存储空间，空间复杂度为 **O(1)**。

**时间复杂度**：最坏情况，遍历完整个数组，时间复杂度为 **O(![n^\{2\}][n_2])**。

### 【**算法缺陷**】 ###

解法1 是一种比较笨的方法，是利用**穷举法**思想来解决问题的。显然，这种解法不是很好，因为它的时间复杂度是 O(![n^\{2\}][n_2])，算法的执行效率太低，如果有时间限制的话，肯定是通不过测试的。

### 解法2 — 推荐解法 ###

根据题意可知，一元数组 nums 有 n 个数组元素，元素取值范围在 0~n-1 之间，而数组的下标范围也是 0~n-1。我们可以将数组元素与其对应的下标值作大小比较，如果相等则跳过，遍历下一个数组元素；如果不等，则将该元素与以该元素值为下标所对应的数组元素进行比较，如果相等，就表示找到了一个重复的元素，并返回该元素的值，不相等则将这两个元素值交换。

### 【算法描述】C语言实现 ###

int findRepeatNumber(int* nums, int numsSize){
        if(nums == NULL || numsSize <= 0)
            return -1;
        
        int i = 0;
        while(i<numsSize){
            if(i == nums[i]){
                i++;
                continue;
            }
            else{
                int tmp = nums[i];            //将a[i]赋值给临时变量tmp
                if(nums[i] == nums[tmp])      //如果相等，则返回重复元素值
                    return nums[i];
                else{                         //如果不等，则交换
                    nums[i] = nums[tmp];
                    nums[tmp] = tmp;
                }
            }
        }
    
        return -1;
    }

### 【**算法复杂度**】 ###

**空间复杂度**：没有开辟新的存储空间，空间复杂度为 O(1)。

**时间复杂度**：最坏情况，遍历完整个数组，时间复杂度为 O(n)。

## **⭐️本题考点⭐️** ##

*  考察对一维数组的理解和编程能力。一维数组在内存中占据连续的存储空间，因此我们可以根据下标定位对应的元素。

# **⭐️题目二描述⭐️** #

> 不修改数组找出重复的数字。
> 
> 在一个长度为 n+1 的数组里所有数字都在 1~n 的范围内，所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但不能修改输入的数组。

**示例1：**

> 如果输入长度为 8 的数组=\{ 2, 3, 5, 4, 3, 2, 6, 7\}，那么对应的输出是重复的数字：2 或者 3。

## **⭐️解题思路⭐️** ##

由于数组长度为 n+1，而数组元素的取值范围是 1~n，所以一定包含了重复的数字。我们可以使用**二分法**思想来解决这个问题。算法步骤如下：

（1）我们把 1~n 这个取值范围从中间的数字mid，一分为二，前半部分是 1~mid，后半部分是 mid+1~n。如果 1~mid 的数字的个数超过了 mid，说明这一半的区间里一定含有重复的数字；否则，另一半 mid+1~n 的区间里一定包含重复的数字。

（2）继续把包含重复数字的区间一分为二，直到找到一个重复的数字。这个查找重复数字的过程类似于**二分查找算法**，只是多了一步统计区间里数字的数目。

我们以长度为 8 的数组=\{ 2, 3, 5, 4, 3, 2, 6, 7\}为例来分析整个查找过程。

*  这个长度为 8 的所有数字都在 1~7 的取值范围内。中间数字 4 把这个 1~7 的区间划分为二段，一段是 1~4，另一段是 5~7。接下来我们统计 1~4 这4个数字在数组中出现的次数，它们一共出现了 5 次，因此这4个数字中一定有重复的数字。
 *  接下来我们再把 1~4 的区间一分为二，一段是 1、2两个数字，另一段是 3、4两个数字。数字1、2在数组中一共出现了两次，而数字 3、4在数组中一个出现了 3 次，这说明 3 、4 这两个数字中一定有一个重复了。
 *  我们再分别统计数字3、4在数组中出现的次数。然后我们可以发现，数字 3 出现了两次，是一个重复的数字。

### 【算法描述】C语言描述 ###

//计算数组元素的取值在start~end区间范围内的个数
    int countRange(const int *nums, int length, int start, int end)
    {
        if(nums == NULL)
            return 0;
        
        int count = 0;
        for(int i=0; i<length; i++)
        {
            if(nums[i]>=start && nums[i]<=end)
                ++count;
        }
        return count;
    }
    
    //获取数组元素重复的数字
    int getDuplication(const int *nums, int length)
    {
        if(nums == NULL || length <= 0)
            return -1;
        
        int start = 1;
        int end = length - 1;
        
        while(start <= end)
        {
            int mid = (start+end)/2;
            int count = countRange(nums, length, start, mid);
            if(start == end)
            {
                if(count > 1)
                    return start;
                else
                    break;
            }
            
            if(count > (mid - end + 1))  //如果前半区间有重复数字
                end = mid;
            else                         //否则，后半区间有重复数字
                start = mid + 1;
        }
        
        return -1;
    }

### **【测试用例】** ###

#include <stdio.h>
    
    // ====================测试代码====================
    void test(const char* testName, int* numbers, int length, int* duplications, int dupLength)
    {
        int result = getDuplication(numbers, length);
        for(int i = 0; i < dupLength; ++i)
        {
            if(result == duplications[i])
            {
                printf("%s passed.\n", testName);
                return;
            }
        }
        printf("%s FAILED.\n", testName);
    }
    
    // 多个重复的数字
    void test1()
    {
        int numbers[] = { 2, 3, 5, 4, 3, 2, 6, 7 };
        int duplications[] = { 2, 3 };
        test("test1", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 一个重复的数字
    void test2()
    {
        int numbers[] = { 3, 2, 1, 4, 4, 5, 6, 7 };
        int duplications[] = { 4 };
        test("test2", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 重复的数字是数组中最小的数字
    void test3()
    {
        int numbers[] = { 1, 2, 3, 4, 5, 6, 7, 1, 8 };
        int duplications[] = { 1 };
        test("test3", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 重复的数字是数组中最大的数字
    void test4()
    {
        int numbers[] = { 1, 7, 3, 4, 5, 6, 8, 2, 8 };
        int duplications[] = { 8 };
        test("test4", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 数组中只有两个数字
    void test5()
    {
        int numbers[] = { 1, 1 };
        int duplications[] = { 1 };
        test("test5", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 重复的数字位于数组当中
    void test6()
    {
        int numbers[] = { 3, 2, 1, 3, 4, 5, 6, 7 };
        int duplications[] = { 3 };
        test("test6", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 多个重复的数字
    void test7()
    {
        int numbers[] = { 1, 2, 2, 6, 4, 5, 6 };
        int duplications[] = { 2, 6 };
        test("test7", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 一个数字重复三次
    void test8()
    {
        int numbers[] = { 1, 2, 2, 6, 4, 5, 2 };
        int duplications[] = { 2 };
        test("test8", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 没有重复的数字
    void test9()
    {
        int numbers[] = { 1, 2, 6, 4, 5, 3 };
        int duplications[] = { -1 };
        test("test9", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int));
    }
    
    // 无效的输入
    void test10()
    {
        int* numbers = NULL;
        int duplications[] = { -1 };
        test("test10", numbers, 0, duplications, sizeof(duplications) / sizeof(int));
    }
    
    //测试代码
    int main()
    {
        test1();
        test2();
        test3();
        test4();
        test5();
        test6();
        test7();
        test8();
        test9();
        test10();
        
        return 0;
    }

### 【**运行结果**】 ###

> test1 passed.  
> test2 FAILED.  
> test3 passed.  
> test4 FAILED.  
> test5 passed.  
> test6 FAILED.  
> test7 FAILED.  
> test8 FAILED.  
> test9 passed.  
> test10 passed.

### 【算法复杂度】 ###

**空间复杂度**：没有开辟新的存储空间，空间复杂度为 O(1)。

**时间复杂度**：如果输入长度为 n 的数组，那么函数 countRange 将被调用 O(![\\log n][log n])次，每次需要 O(n) 的时间，因此总的时间复杂度是 O(![n\\log n][n_log n])。

### 【算法说明】 ###

需要指出的是，这种算法不能保证找出所有重复的数字。例如，该算法不能找出 数组=\{2, 3, 5, 4, 3, 2, 6, 7\} 中重复的数字2。这是因为在 1~2 的范围里有1 和 2 两个数字，这个范围的数字也出现 2 次，此时我们用该算法就不能确定是每个数字各出现一次还是某个数字出现了两次。

### 【拓展思考】 ###

如果是要找出数组中所有重复的数字。又该如何处理呢？感兴趣的话，可以自己尝试一下如何解决。

## **⭐️本题考点⭐️** ##

*  考察对一维数组的理解及编程能力。
 *  考察对二分法思想的理解，并能快速、正确地实现二分查找算法的代码。

# 参考 #

《剑指Offer：名企面试官精讲典型编程题(第2版)》

[https_leetcode-cn.com_problems_shu-zu-zhong-zhong-fu-de-shu-zi-lcof]: https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/
[n_2]: https://latex.codecogs.com/gif.latex?n%5E%7B2%7D
[log n]: https://latex.codecogs.com/gif.latex?%5Clog%20n
[n_log n]: https://latex.codecogs.com/gif.latex?n%5Clog%20n