学习记录：js算法（三十二）：寻找重复数

寻找重复数

给定一个包含 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

我的思路
双指针
网上思路
二分法、递归

我的思路

var findDuplicate = function (nums) {
    let tortoise = nums[0], hare = nums[0];
    do {
        tortoise = nums[tortoise];
        hare = nums[nums[hare]];
    } while (tortoise !== hare);
    tortoise = nums[0];
    while (tortoise !== hare) {
        tortoise = nums[tortoise];
        hare = nums[hare];
    }
    return hare;
};

讲解
此题可以利用 Floyd 判圈算法（龟兔赛跑算法）来解决，这个算法通常用于检测链表中是否存在环，但在这种情况下，我们可以将其应用于数组中来寻找重复的数字。这个方法的关键在于把数组看作是一个有向图，其中每个数字都是一个节点，而数字的值指示了从当前节点到下一个节点的边。

1. 初始化快慢指针：将两个指针 tortoise 和 hare 初始化为数组的第一个元素的值（而不是数组的索引）。这是因为我们将值视为节点，值的指向视为边。
2. 检测循环：使用快慢指针的原理来检测循环。hare 指针每次跳两步，tortoise 指针每次跳一步。如果存在重复的数字，那么一定存在循环，hare 最终会追上 tortoise。
3. 定位入口点：一旦发现 hare 追上了 tortoise，将 tortoise 指针移回起点，然后让 tortoise 和 hare 以相同的速度前进，直到它们再次相遇。相遇点就是循环的入口点，也就是重复的数字。

网上思路

解法一：二分法

var findDuplicate = function(nums) {
  let low = 1, high = nums.length - 1;
  while (low < high) {
    const mid = Math.floor((low + high) / 2);
    let count = 0;
    for (let num of nums) {
      if (num <= mid) {
        count++;
      }
    }
    if (count > mid) {
      high = mid;
    } else {
      low = mid + 1;
    }
  }
  return low;
};

讲解
一个容易理解的解法是使用二分查找的思想。这种方法适用于题目中的条件，即所有数字都在[1, n]范围内，且数组的长度为n+1。
既然数组的长度比其应有的最大值多一个，那么一定有一个数至少出现了两次。我们可以用二分查找来缩小重复数的范围。步骤如下：

1. 初始化边界：设定左边界 low = 1 和右边界 high = n 。
2. 二分查找：在 [low, high] 区间内选取中间值 mid ，然后遍历数组，统计小于等于 mid 的元素个数count。
3. 分析结果：
   ○ 如果 count 大于 mid ，这意味着在 [1, mid] 范围内至少有一个数重复了（因为正常的不重复情况下，最多有 mid 个数小于等于 mid ），此时将右边界 high 更新为 mid 。
   ○ 否则，重复的数在 [mid+1, high] 范围内，将左边界 low 更新为 mid + 1。
4. 重复步骤 2 和 3，直到 low == high，此时 low（或high） 即为重复的数字。

解法二：递归

var findDuplicate = function (nums) {
    const n = nums.length - 1;
    const search = (left, right) => {
        if (left >= right) return left;
        const mid = Math.floor((left + right) / 2);
        let count = 0;
        for (let num of nums) {
            if (num >= left && num <= mid) {
                count++;
            }
        }
        if (count > mid - left + 1) {
            return search(left, mid);
        } else {
            return search(mid + 1, right);
        }
    };
    return search(1, n);
};

讲解
思路：
理解问题：数组中的数字在 [1, n] 范围内，且有一个重复的数字。我们可以利用这个特性来进行二分查找。
分治法：我们可以在每次递归中将数组分为两部分，并统计在当前范围内的数字数量。通过比较数字的数量与中间值，可以判断重复数字在左半部分还是右半部分。
递归实现：如果在某一范围内，数字的数量超过了该范围的大小，说明在这个范围内存在重复数字。我们可以继续在这个范围内进行递归查找。
具体：

1. 递归函数 search：
   left 和 right 是当前查找的范围。
   如果 left 等于或大于 right，返回 left，这就是重复的数字。
2. 计算中间值 mid：每次递归时计算当前范围的中间值。
3. 统计数字数量：遍历数组，统计在 [left, mid] 范围内的数字数量。
4. 判断范围：
   如果在 [left, mid] 范围内的数字数量大于该范围的大小，说明重复数字在左半部分，继续在左半部分递归。
   否则，继续在右半部分递归。

总结

今天这道题的解法挺多的。