Medium | LeetCode 287. 寻找重复数 | 二分法 | Floyd判圈法(环形链表)

287. 寻找重复数

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

假设 nums 只有 一个重复的整数 ，找出 这个重复的数 。

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

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

提示：

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

进阶：

• 如何证明 nums 中至少存在一个重复的数字?
• 你可以在不修改数组 nums 的情况下解决这个问题吗？
• 你可以只用常量级 O(1) 的额外空间解决这个问题吗？
• 你可以设计一个时间复杂度小于 O(n^2) 的解决方案吗？

解题思路

错误解法一： 位运算

N + 1个数, 每个数字出现的范围都在[1, N]之间。乍一看和Easy | LeetCode 268. 丢失的数字 | 位运算有几分相似。在 LeetCode 268. 丢失的数字 当中, 是[1,N]范围的N个数, 但是数组的下标是[0,N], 可容纳N+1个数, 要找出那唯一一个没有出现的数字。而此题看似相反, 要找出多出来的那个数。例如示例1 多出来的是2。于是写出如下的代码。

public int findDuplicate(int[] nums) {
    int res = 0;
    for (int i = 0; i < nums.length; i++) {
        res ^= i ^= nums[i];
    }
    return res;
}

但是, 这种思路是不符合题意的。因为上面的代码只能处理, 这个重复数字只出现一次的情况, 其他的数字全都出现。例如示例1当中, 数字2出现了2次, 并且其他的数字1,3,4全部都出现了。对于某个数组重复2此以上, 但是其他的数字还有未出现的情况, 以上代码是无法处理的。

非标准方法一：哈希

用一个额外的长度为N的数组对原数组出现的数字进行计数。找到出现了2次的数字就返回结果即可。

时间复杂度：O(N), 空间复杂度：O(N)

非标准方法二： 排序

将数组排序, 然后扫描数组, 找到两个相邻的且相等的数字即返回。

但是题目要求不能改变原始数组, 所以这种解法需要将原数组复制一份。时间复杂度：O(NlogN), 空间复杂度： O(N)。

---

方法一: 二分查找

这道题能够使用二分查找的方法似乎不是很好想明白。一般来讲, 要使用二分查找需要原数组保持有序, 即原数组具有一定的单调性。每次通过中间值与期望目标值的比较来排除一半。

不过这里的二分法的对象有所不同, 设cnt[i] 表示小于或者等于 i 的元素的个数。因为本题题目所给的数据具有一定的特点。譬如给定数组为[1,4,3,3,3], 假设对其排序得到[1,3,3,3,4]。那么在这个重复的数的位置, 会发生cnt[i] >= i。即cnt[1] = 1, cnt[2] = 1 (因为2发生了缺失), cnt[3] = 4, cnt[4] = 5。所以可以发现

1. 如果i小于目标值, 则有cnt[i] <= i, 例如上例里 cnt[1] = 1, cnt[2] = 1。
2. 如果i大于等于目标值, 则有cnt[i] > i, 例如上例里 cnt[3] = 4, cnt[4] = 5。这是因为重复数据多占了位置。

用另外一种更加朴素的思路来讲。
假如N个无重复的数字的范围[1, N]。 那么很容易想到此数组是1,2,3....N的无序数组。
现在稍作更改, 改为N+1个数字, 每个数字范围是[1,N], 可以很容易想到, 就是在上述的数组下再添加一个[1,N]的数字, 于是很容易知道, 这N+1个数字一定有重复。 假如就是在1,2,3,4...N的数组里添加一个[1,N]的数字, 假如添加4, 则在添加4之前有cnt[i] = i。在添加4之后, 可以知道对于小于4的数字有cnt[i] = i, 4及之后有cnt[i] > i。
下面再在上面的基础上做更改, 把[1,2,3,4,4,5 ....N] 里的2改为4, 得到[1,3,4,4,4,5....N] , 则在目标值之前有cnt[i] <= [i], 在目标值之后有cnt[i] > i;
所以只需要找到第一个cnt[i] > i 的值即可。根据以上的规律, 使用二分法即可。

public int findDuplicate(int[] nums) {
    int n = nums.length;
    int l = 1, r = n - 1, ans = -1;
    while (l <= r) {
        int mid = (l + r) >> 1;
        int cnt = 0;
        // 统计小于等于i的元素的个数
        for (int i = 0; i < n; ++i) {
            if (nums[i] <= mid) {
                cnt++;
            }
        }
        if (cnt <= mid) {
            // cnt[i] <= i, 则小于 i 的值, 全都不是目标值
            l = mid + 1;
        } else {
            // cnt[i] > i, 当前mid值可能成为目标值
            r = mid - 1;
            // 保存当前的i值, 这种写法如果[l, mid-1]中没有目标值, 那么当前的ans就是最终的结果
            ans = mid;
        }
    }
    return ans;
}

这种解法的时间复杂度是:O(NlogN), 空间复杂度是O (1)。虽然排序的时间复杂度也是O(NlogN), 但是题目要求不能修改原始数组。所以此种解法是一种比排序算法更符合题目要求的解法。

方法二： Floyd判圈法

一个非常巧妙的方法是这道题可以看做是链表。不妨从下标i处出发, 将下标i的数字 画一个箭头, 指向下标为nums[i]的地方, 然后走到下标为nums[i]这个地方, 继续之前的画箭头操作。 由于题目中的数字有重复, 那么一定会有两个下标i, j , 指向同一个下标(nums[i] = nums[j])。于是得到了一个有环的链表。而要寻找重复数等价于要找环的入口。此题就与 Medium | LeetCode 142. 环形链表 II 类似了。

public int findDuplicate(int[] nums) {
    int slow = 0, fast = 0;
    // 首先设置慢指针每次走一步, 快指针每次走两步, 让快慢指针相遇
    do {
        slow = nums[slow];
        fast = nums[nums[fast]];
    } while (slow != fast);
    // 然后让慢指针回到链表头
    slow = 0;
    // 快慢指针同时走, 当快慢指针相遇时, 就是环的入口。
    while (slow != fast) {
        slow = nums[slow];
        fast = nums[fast];
    }
    return slow;
}