LeetCode-287. 寻找重复数-Java-medium

题目链接

法一（set）

    /**
     * 法一（set）
     * 时间复杂度 0(n)
     * 空间复杂度 0(n)
     *
     * @param nums
     * @return
     */
    public int findDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return nums[i];
            }
            set.add(nums[i]);
        }
        return -1;
    }

法二（二分）

    /**
     * 法二（二分）
     * 1. 思路
     * （1）先重复的那个数字肯定是1到n中的某一个，而1,2...,n是一个有序序列
     * （2）因此可以对1,2...,n进行二分查找
     * 2. 复杂度
     * （1）时间复杂度 O(nlogn)
     * （2）空间复杂度 0(1)
     *
     * @param nums
     * @return
     */
    public int findDuplicate_2(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = left + (right - left) / 2; // 判断结果是在[left, mid]中还是在[mid + 1, right]中
            int cnt = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] <= mid) { // 统计原数组中小于等于mid的元素个数
                    cnt++;
                }
            }
            if (cnt > mid) { // 原数组在[left, mid]范围内的元素个数超过了mid，则[left, mid]中一定有一个重复数字
                right = mid;
            } else { // 原数组在[left, mid]范围内的元素个数不超过mid，则[mid + 1, right]中一定有一个重复数字
                left = mid + 1;
            }
        }
        return left;
    }

法三（双指针）

    /**
     * 法三（双指针）
     * 1. 思路
     * （1）将数组的值看成next指针，数组的下标看成节点的索引
     * （2）数组中至少有两个值一样，说明有两个节点指向同一个位置，故一定会出现环
     * 2. 步骤
     * （1）设置快慢指针，同时从起点出发，慢指针一次走一步，快指针一次走两步，然后记录快慢指针相遇的点
     * （2）之后再用两个指针，一个指针从起点出发，一个指针从相遇点出发，则相遇处即为入环的第一个节点
     * 3. 复杂度
     * （1）时间复杂度 O(n)
     * （2）空间复杂度 0(1)
     * 4. 理解
     * 例如：3 1 3 4 2
     * nums[0] = 3
     * nums[3] = 4
     * nums[4] = 2
     * nums[2] = 3
     *
     * @param nums
     * @return
     */
    public int findDuplicate_3(int[] nums) {
        int slow = nums[0];
        int fast = nums[nums[0]];
        while (slow != fast) { // 寻找快慢指针相遇点
            slow = nums[slow];
            fast = nums[nums[fast]];
        }
        int start = 0;
        while (start != slow) { // start从起点出发，slow从相遇点出发，一次走一步
            start = nums[start];
            slow = nums[slow];
        }
        return start; // 再次相遇处即为入环的第一个节点
    }

法四（负数标记）

    /**
     * 法四（负数标记）
     * 1. 思路
     * （1）把当前数字对应下标的数字取负，如果已经是负数说明出现过了，直接返回当前数字的绝对值
     * 2. 复杂度
     * （1）时间复杂度 O(n)
     * （2）空间复杂度 0(1)
     *
     * @param nums
     * @return
     */
    public int findDuplicate_4(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            int abs = Math.abs(nums[i]);
            if (nums[abs] < 0) {
                return abs;
            } else {
                nums[abs] = -nums[abs];
            }
        }
        return 0;
    }

本地测试

        /**
         * 287. 寻找重复数
         */
        lay.showTitle(287);
        Solution287 sol287 = new Solution287();
        int[] nums287 = new int[]{3, 1, 3, 4, 2};
        System.out.println(Arrays.toString(nums287));
        System.out.println(sol287.findDuplicate(nums287));
        System.out.println(sol287.findDuplicate_2(nums287));
        System.out.println(sol287.findDuplicate_3(nums287));
        System.out.println(sol287.findDuplicate_4(nums287));