287. 寻找重复数

题解：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

二分查找
思路：

这道题要求我们查找的数是一个整数，并且给出了这个整数的范围（在 1和 n 之间，包括 1 和 n），并且给出了一些限制，于是可以使用二分查找法定位在一个区间里的整数；

二分法的思路是先猜一个数（有效范围 [left, right]里的中间数 mid），然后统计原始数组中小于等于这个中间数的元素的个数 cnt，如果 cnt 严格大于 mid，（注意我加了着重号的部分「小于等于」、「严格大于」）。根据抽屉原理，重复元素就在区间 [left, mid] 里；

与绝大多数二分法问题的不同点是：正着思考是容易的，即：思考哪边区间存在重复数是容易的，因为有抽屉原理做保证。我们通过一个具体的例子来分析应该如何编写代码；

以 [2, 4, 5, 2, 3, 1, 6, 7] 为例，一共 8 个数，n + 1 = 8，n = 7，根据题目意思，每个数都在 1 和 7 之间。

例如：区间 [1, 7]的中位数是 4，遍历整个数组，统计小于等于 4 的整数的个数，最多为 4个，等于 4 的时候也可能有重复。但是，如果整个数组里小于等于 4 的整数的个数如果严格大于 4 个，就说明重复的数存在于区间 [1,4]。

说明：由于这个算法是空间敏感的，「用时间换空间」是反常规做法，算法的运行时间肯定不会高。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int left = 1;
        int right = nums.size()-1;
        while(left < right) {
            int mid = (left+right) >> 1;
            int count = 0;
            for(auto ite : nums) {
                if(ite <= mid) {
                    ++count;
                }
            }
            if(count > mid) {
                right = mid;
            } else {
                left = mid+1;
            }
        }
        return left;
    }
};

class Solution {
public:
    int findDuplicate(vector<int> &nums) {
        int len = nums.size();
        int left = 1;
        int right = len - 1;

        while (left < right) {
            int mid = left + (right - left) / 2;

            int cnt = 0;
            for (int num:nums) {
                if (num <= mid) {
                    cnt++;
                }
            }

            // 根据抽屉原理，小于等于 4 的数的个数如果严格大于 4 个，
            // 此时重复元素一定出现在 [1, 4] 区间里

            if (cnt > mid) {
                // 重复的元素一定出现在 [left, mid] 区间里
                right = mid;
            } else {
                // if 分析正确了以后，else 搜索的区间就是 if 的反面
                // [mid + 1, right]
                // 注意：此时需要调整中位数的取法为上取整
                left = mid + 1;
            }
        }
        return left;
    }
};

复杂度分析：

时间复杂度：O(NlogN)，二分法的时间复杂度为 O(logN)，在二分法的内部，执行了一次 for 循环，时间复杂度为 O(N)，故时间复杂度为O(NlogN)。
空间复杂度：O(1)，使用了一个 cnt 变量，因此空间复杂度为O(1)。

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        for (int i = 0; i < nums.size(); ++i) {
            while (nums[i] != i+1) {
                if (nums[nums[i]-1] == nums[i]) {
                    return nums[i];
                }
                swap(nums[i], nums[nums[i]-1]);
            }
        }
        return 1;
    }
};