寻找重复数

题目

给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。

示例 1:
输入: [1,3,4,2,2]
输出: 2

示例 2:
输入: [3,1,3,4,2]
输出: 3

说明：

1. 不能更改原数组（假设数组是只读的）。
2. 只能使用额外的 O(1) 的空间。
3. 时间复杂度小于 O(n2) 。
4. 数组中只有一个重复的数字，但它可能不止重复出现一次。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-the-duplicate-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

1. 哈希查找——额外的O(N)空间，违反规则2

为降低时间复杂度，采用哈希表或者字典的方法，建立原数组元素和出现次数的键值对，只有一个重复的数字，所以判断在哈希表中存在时即证明是要寻找的重复数。

2. 二分法

时间复杂度为 O(logN)
空间敏感的「用时间换空间」是反常规做法。

查找一个有范围的整数

解题时考虑抽屉原理

• 抽屉原理

举例来说，假设有10个苹果，可以装在9个抽屉里，则至少有1个抽屉里有至少2个苹果。

思路：取有效取件 [left, right]里的中间数 mid，统计原数组中 ≤ mid的元素个数 count（新变量），如果 cnt 严格大于 mid，根据抽屉原理，重复元素就在区间 [left, mid] 里，再继续在该区间上二分。

本题数组长度限定，数组元素大小也有限定，不管元素重复顺序如何，通过大小分开比较，能够找到重复的唯一数字。

例如 [1,3,4,2,2]，中间值为 2 ，数组中 ≤ 2 的数字有3个（1，2，2），3 严格大于 2 ，故重复数字就在 [1,2] 中。

3. 快慢指针
   求环的第一个节点，即环的入口，为重复元素。
   思路：先找到环，再找到环的入口

• 找环
  标志：走得快的指针与走得慢的指针相遇在同一位置
  步骤：
  • 定义快慢指针slow=0,fast=0
  • 进入循环：
    slow每次走一步，即slow=nums[slow]
    fastfast每次走两步，即fast=nums[nums[fast]]
    当slow==fast时，退出循环。
  • 快慢指针相遇必在环内
    假设起点到环的入口(重复元素)，需要m步。此时slow走了n+m步，其中n是环的周长c的整数倍，相遇时一定是环的入口。

代码

哈希查找（非适用）

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        Hash = {}
        count = 0
        for i in range(len(nums)):
            if nums[i] in Hash:
                count += 1
                return nums[i]
            Hash[nums[i]] = count

• 结果

• 时间复杂度O(N)，一次遍历，哈希查找O(1)
• 空间复杂度O(N)

二分法

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        left = 1
        right = len(nums) - 1
        while left < right:
            mid = (left + right)//2
            count = 0
            for i in nums:
                if i <= mid:
                    count += 1
            if count > mid:
                right = mid
            else:left = mid + 1
        return left

• 时间复杂度O(N log N)，二分法O(log N)，内部一次遍历O(N)
• 空间复杂度O(1)，新变量count

快慢指针

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        slow = nums[0]
        fast = nums[nums[0]]
        while slow != fast:
            slow = nums[slow]
            fast = nums[nums[fast]]
        slow = 0
        while slow != fast:
            slow = nums[slow]
            fast = nums[fast]
        return slow

• 时间复杂度：O(N)，while循环
• 空间复杂度：O(1)，仅指针

总结学习

1. 二分查找，针对有序数列，本题仅存在一个重复数字，遍历比较数组元素小于等于中间值的个数，从而逐步缩小搜索范围，缺点是时间牺牲；
2. 环结构的运用，快慢指针的理解。