挑战30天每天一道leetcode题：Day6 #287寻找重复数

题目：#287寻找重复数

给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。

假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。

你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。

示例 1：

输入：nums = [1,3,4,2,2]
输出：2

示例 2：

输入：nums = [3,1,3,4,2]
输出：3

示例 3 :

输入：nums = [3,3,3,3,3]
输出：3

提示：

• 1 <= n <= 105
• nums.length == n + 1
• 1 <= nums[i] <= n
• nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次

进阶：

• 如何证明 nums 中至少存在一个重复的数字?
• 你可以设计一个线性级时间复杂度 O(n) 的解决方案吗？

链接：. - 力扣（LeetCode）

参考代码

package com.atguigu.algorithm.binary_search;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;

public class FindDuplicateNumber {
    //  方法一：使用HashMap保存每个数出现的次数
    public int findDuplicate1(int[] nums) {
        HashMap<Integer, Integer> countMap = new HashMap<>();
        //  遍历所有元素，统计count值
        for (int num : nums) {
            //判断当前的num 是否在map 中出现过
            if (countMap.containsKey(num)) {
                return num;     // 如果出现过，num就是重复数
            } else {
                countMap.put(num, 1);
            }
        }
        return -1;
    }

    //  方法二：使用HashSet保存数据，判断是否出现过
    public int findDuplicate2(int[] nums) {
        HashSet<Integer> hashSet = new HashSet<>();
        //  遍历所有元素，添加到set中
        for (int num : nums) {
            //  判断当前mum是否在map中出现过
            if (hashSet.contains(num)) {
                return num;
            } else {
                hashSet.add(num);   //  如果出现过，num就是重复数
            }
        }
        return -1;
    }

    //  方法三：先排序，然后找相邻的相同元素
    public int findDuplicate3(int[] nums) {
        Arrays.sort(nums);
        //  遍历数组元素，遇到跟前一个相同的，就是重复元素
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == nums[i - 1]) {
                return nums[i];
            }
        }
        return -1;
    }



    //方法四：二分查找，查找1~N 的自然数序列，寻找target
    public int findDuplicate(int[] nums) {
        //  定义左右指针
        int left = 1;
        int right = nums.length - 1;

        while (left <= right) {
            //  计算中间值
            int mid = (left + right) / 2;
            //  对当前的mid计算count值
            int count = 0;
            for (int j = 0; j < nums.length; j++) {
                if (nums[j] < mid) {
                    count++;
                }
            }

            //  判断count和mid本身的大小关系,
            //  用例子理解{1，2，5，6，6，6，6，6，7，9}，mid=5,count=2,target指重复数6
            //{1，2，3，4，4，4，4，5，7，9} , mid=5,count=7,target=3
            if (count <= mid) {
                left = mid + 1;     //count<=mid自身，说明mid<target，左指针右移
            }else {
                right = mid;   
            }

            //左右指针重合时，找到target
            if (left == right) {
                return left;
            }
        }
        return -1;
    }


    public static void main(String[] args) {
        int[] num1 = {1, 3, 4, 2, 2};
        int[] num2 = {1, 1};
        FindDuplicateNumber findDuplicateNumber = new FindDuplicateNumber();
        System.out.println(findDuplicateNumber.findDuplicate(num1));
        System.out.println(findDuplicateNumber.findDuplicate(num2));
    }
}

复杂度分析

方法一二：

时间复杂度：O(n)，我们只对数组做了一次遍历，在HashMap和HashSet中查找的复杂度是O(1)。

空间复杂度：O(n)，我们需要一个HashMap或者HashSet来做额外存储，最坏情况下，这需要线性的存储空间。

方法三：

时间复杂度： O(nlgn)。对数组排序，在Java 中要花费 O(nlgn) 时间，后续是一个线性扫描，所以总的时间复杂度是O(nlgn)。

空间复杂度： O(1) (or O(n))，在这里，我们对 nums 进行了排序，因此内存大小是固定的。当然，这里的前提是我们可以用常数的空间，在原数组上直接排序。如果我们不能修改输入数组，那么我们必须把 nums 拷贝出来，并进行排序，这需要分配线性的额外空间。

方法四：

时间复杂度：O(nlog n)，其中 n 为nums[] 数组的长度。二分查找最多需要O(logn) 次，而每次判断count的时候需要O(n) 遍历 nums[] 数组求解小于等于 i 的数的个数，因此总时间复杂度为O(nlogn)。

空间复杂度：O(1)。我们只需要常数空间存放若干变量。