【剑指offer】第50题：数组中重复的数字

最新推荐文章于 2023-07-27 09:34:35 发布

DJames23

最新推荐文章于 2023-07-27 09:34:35 发布

阅读量126

点赞数

分类专栏：剑指offer 文章标签：数据结构算法

本文链接：https://blog.csdn.net/DJames23/article/details/112365052

版权

剑指offer 专栏收录该内容

65 篇文章 0 订阅

订阅专栏

题目一：找出数组中重复的数字
描述：在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中第一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
返回描述：
如果数组中有重复的数字，函数返回true，否则返回false。
如果数组中有重复的数字，把重复的数字放到参数duplication[0]中。（ps:duplication已经初始化，可以直接赋值使用。）

import java.util.HashSet;
import java.util.Set;
import java.util.Arrays;
public class Solution {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        //思路五：操作原数组,交换，时间复杂度(n),空间复杂度O(1)
        /*
以数组 {2,3,1,0,2,5,3} 为例
当 i = 0 时，nums[i] = 2 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{1,3,2,0,2,5,3}
此时 i = 0，nums[i] = 1 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{3,1,2,0,2,5,3}
此时 i = 0，nums[i] = 3 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{0,1,2,3,2,5,3}
此时 i = 0，nums[i] = 0 = i，继续下一组
当 i = 1，nums[i] = 1 = i，继续下一组
当 i = 2，nums[i] = 2 = i，继续下一组
当 i = 3，nums[i] = 3 = i，继续下一组
当 i = 4，nums[i] = 2 != i，判断 nums[i] 等于 nums[nums[i]]，出现重复，赋值返回
        */
        if(numbers == null || length ==0){
            return false;
        }
        for(int i=0;i<length;i++){
            while(i != numbers[i]){
                if(numbers[i] == numbers[numbers[i]]){
                    duplication[0] = numbers[i];
                    return true;
                }else{
                    int temp = numbers[i];
                    numbers[i] = numbers[temp];
                    numbers[temp] = temp;
                }
            }
        }
        return false;
    }
}

		 //思路一：使用辅助数组记录数字出现的次数，当遇到第一个重复数字时就return，O(n)
        int[] index = new int[length];
        for(int i=0;i< length;i++){
            if(index[numbers[i]] == 0){
                index[numbers[i]]++;
            }else{
                duplication[0] = numbers[i];
                return true;
            }
        }
        return false;

		//思路二：暴力，O(n2)
        for(int i =0; i < length;i++){
            for(int j= i+1;j< length;j++){
                if(numbers[i] == numbers[j]){
                    duplication[0] = numbers[i];
                    return true;
                }
            }
        }
        return false;

 //思路三：哈希表,时间与空间复杂度都是O(n)
        Set<Integer> set = new HashSet<Integer>();
        for(int i =0;i< length;i++){
            if(set.contains(numbers[i])){
               duplication[0] = numbers[i];
               return true;
            }else{
                set.add(numbers[i]);
            }
        }
        return false;

  //思路四：排序,时间复杂度O（nlogn）
        if(numbers == null || length == 0){
            return false;
        }
        Arrays.sort(numbers);
        for(int i=0;i<length-1;i++){
            if(numbers[i] == numbers[i+1]){
                duplication[0] = numbers[i];
                return true;
            }
        }
        return false;

题目二：不修改数组找出重复的数字
在一个长度为n+1的数组里的所有数字都在1~n的范围内，所以数组中至少有一个是重复的。请找出数组中任意一个重复的数字，但不能修改输入的数组。例如，如果输入长度为8的数组{2，3，5，4，3，2，6，7}，那么对应的输出是重复的数字2或3.

思路一：仍然可以使用辅助数组，需要O(n)的辅助空间。
思路二：采用二分法。
以长度为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、4两个数字中一定有一个重复了。我们再分别统计这两个数字在数组中出现的次数。接着我们发现3出现了两次，是一个重复的数字。
java代码如下：

public class Solution3second {
    //P41-面试题3题目2：不修改数组找出重复的数字
    public static void main(String[] argvs){
        int[] number = {2,3,5,4,3,2,6,7};
        int length = number.length;
        int[] duplication = new int[1];
        int res = getDuplication(number,length,duplication);
        System.out.println(res);
    }
    public static int getDuplication(int[] number, int length, int[] duplication){
        if (number == null || length == 0){
            return -1;
        }
        int start = 1;
        int end = length - 1;
        while (end >= start){
            int middle = ((end - start) / 2) + start;
            int count = countRange(number, length, start, middle);
            if (end == start){
                if (count > 1){
                    return start;
                }else {
                    break;
                }
            }
            if (count > (middle -start + 1)){
                end = middle;
            }else {
                start = middle + 1;
            }
        }
        return -1;
    }

    public static int countRange(int[] number, int length, int start, int end){
        if (number == null){
            return 0;
        }
        int count = 0;
        for(int i=0;i<length;i++){
            if (number[i] >= start && number[i] <= end){
                ++count;
            }
        }
        return count;
    }
}

上述代码按照二分查找的思路，如果输入长度为n的数组，那么函数countRange将被调用O(logn)次，每次需要O(n)的时间，因此总的时间复杂度是O(nlogn)，空间复杂度为O(1)。和思路一中的需要O(n)的辅助空间算法相比，这种算法相当于以时间换空间。
需要指出的是，这种算法不能保证找出所有重复的数字。例如，该算法不能找出数组{2，3，5，4，3，2，6，7}中重复的数字2。这是因为在1~2的范围内有1和2两个数字，这个范围的数字也出现两次，因此我们用该算法不能确定是每个数字各出现一次还是某个数字出现了两次。