剑指offer03--数组中重复的数字

剑指 Offer 03. 数组中重复的数字

难度：简单

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 

限制：

2 <= n <= 100000

 

一、HashMap

可以利用哈希表解决这个问题，

1. 从头到尾按顺序扫描数组的每个数字，每扫描一个数字的时候，都可以用O(1) 的时间来判断哈希表里是否已经包含了该数字。
2. 如果哈希表里还没有这个数字，就把他加入到哈希表。
3. 如果哈希表已经存在该数字，就找到一个重复的数字。

这个算法的时间复杂度是O（n），但它提高时间效率是以一个大小为O（n）的哈希表为代价的。

class Solution {
    public int findRepeatNumber(int[] nums) {
        HashMap<Integer,Integer> hash = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(hash.containsKey(nums[i])){
                return nums[i];
            }
            hash.put(nums[i],i);
        }
        return -1;
    }
}

 

二、定义新数组，统计每个数出现的次数

定义一个数组表示原始数组中数字出现的次数，出现一次+1，如果>1了就表示，出现了>1次，返回值就OK

class Solution {
    public int findRepeatNumber(int[] nums) {
        int[] arr = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            arr[nums[i]]++;
            if(arr[nums[i]] > 1) return nums[i];
        }
        return -1;
    }
}

 

三、★★★重排数组，判断索引与索引处的值是否相等

空间复杂度O（1）  

所有操作步骤都是在输入数组上进行的，不需要额外分配内存，因此空间复杂度为O（1）

我们注意到，数组中的数字都在0~n-1的范围内。如果这个数组中没有重复的数字，那么当数组排序之后，数字 i 将出现在下标 i 的位置。由于数组中有重复的数字，有些位置可能存在多个数字，有些位置可能没有数字。

思路：

重排这个数组，

1. 从头到尾依次扫描这个数组的每一个数字。 开始循环 for (int i = 0; i < nums.length; i++)
2. 当扫描到下标为  i 的数字时，首先比较这个数字（用m表示）是不是等于 i 。  比较 nums[i] 与 i 是否相等
3. 如果是，则接着扫描下一个数字。 如果nums[i] == i ，continue，
4. 如果不是，则再拿它和第m个数字进行比较。 如果 nums[i] ！=  i  ，比较nums[i] 和 nums[nums[i]]
5. 如果它和第m个数字相等，就找到了第一个重复的数字（该数字在下标为 i 和 m 出都出现了）。如果相等，返回nums[i]
6. 如果它和第m个数字不相等，就把第i个数字和第m个 数字交换，把m放到属于它的位置。如果不相等，交换nums[i] 和 nums[nums[i]]位置   （有个小坑）
7. 接下来再重复这个比较，交换的过程，直到我们发现一个重复的数字。   结束循环

 

 

2 3 1 0 2 5 3

1 3 2 0 2 5 3    第1次交换了第 0 处的 2 和 第 2 处的 1

1 0 2 3 2 5 3    第2次交换了第 1 处的 3 和 第 3 处的 0

1 0 2 3 2 5 3    第3次，第 2 处的 2  此时 i=nums[i] ，保持不变，继续下次循环

1 0 2 3 2 5 3    第4次，第 3 处的 3  此时 i=nums[i] ，保持不变，继续下次循环

1 0 2 3 2    ------> 输出nums[2] = 2       第5次，第 4 处的 2  与 第 2 处的 2 相等，即出现了第一个重复的数字

 

    public int find2(int[] nums){

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == i) {
                continue;
            }
            else if (nums[i] == nums[nums[i]]) {
                return nums[i];
            }
//               int a = nums[i];
//               nums[i] = nums[nums[i]];
//               nums[nums[i]] = a;
            int a = nums[i];
            nums[i] = nums[a];
            nums[a] = a;
        }
        return -1;
    }

注意：在交换交换nums[i] 和 nums[nums[i]]位置时，注意写法。

 

整理一下：

    public int find2(int[] nums){

        for (int i = 0; i < nums.length; i++) {
            while (i!=nums[i]){
                if (nums[i] == nums[nums[i]]) {
                    return nums[i];
                }
                int a = nums[i];
                nums[i] = nums[a];
                nums[a] = a;
            }
        }
        return -1;
    }

每个数字最多交换两次就能找到属于自己的位置

也可以变成一个排序的小算法

    public int[] find2(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            while (i!=nums[i]){
                int a = nums[i];
                nums[i] = nums[a];
                nums[a] = a;
            }
        }
        return nums;
    }