[数学 位运算 哈希表] 268. 缺失数字（排序法 → HashSet → 位运算、数学计算+避免溢出）_hashset查找缺少的值

268. 缺失数字

题目链接：https://leetcode-cn.com/problems/missing-number/

---

分类：

• 排序（Arrays.sort对数组排序、遍历排序数组寻找缺失值，思路1）
• HashSet（Set存放nums数组所有元素，寻找0~n不存在于set的元素=缺失值，思路2）
• 位运算（异或操作、0…n和nums所有元素的异或结果=缺失值，思路3）
• 数学（sum(0…n) - sum(nums[i]) = 缺失值 + 避免溢出处理，思路4）

---

.
.

思路1：排序 + 遍历 （O(NlogN) O(N)）

对nums数组进行排序，然后遍历一次数组寻找没有出现的数字。

如何寻找数组中缺失某个数字？

因为数组包含的元素范围是0 ~ n，所以排序后如果没有元素缺失则每个元素值和下标是相等的，我们就在遍历排序数组时寻找元素值和下标不同的位置。

缺失的元素在数组边界的处理：
我们所使用的寻找数组缺失数字的方法存在不足，那个方法只能寻找数组内部缺失的数字，但如果缺失数字在数组边界时，例如用例：[0,1]，缺失的是2，该方法就会失效，所以我们令存放缺失数字的变量的初始值为nums.length，在没有找到内部缺失数字后，数组的长度值 = 缺失的边界值。

实现代码：

class Solution {
    public int missingNumber(int[] nums) {
        Arrays.sort(nums);
        int target = nums.length;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != i){
                target = i;
                break;
            }
        }
        return target;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 时间复杂度：O(NlogN)
• 空间复杂度：O(N)

思路2：辅助数组（同HashSet，O(N) O(N)）

开辟一个n+1大小的数组temp，遍历nums数组，对于每个nums[i]就将其存入temp[nums[i]]处。

最后再遍历temp数组，找出值为0的元素所在的下标就是缺失的数字。

但需要注意两种情况：

• 如果temp内只有一个元素temp[0]=0，则说明0就是缺失值；
• 如果temp内有两个=0的元素，则第一个0必然是temp[0]，在这里它不是缺失值，第二个值为0的位置才是缺失值，所以我们返回第二个0对应的下标。

在实现上这两种情况可以统一处理为：

• 寻找temp数组中最晚出现的0元素的所在下标，就是缺失值。

实现代码：

class Solution {
    public int missingNumber(int[] nums) {
        int[] temp = new int[nums.length + 1];
        //将nums所有元素存入temp中，确保nums元素值=temp数组下标
        for(int num : nums){
            temp[num] = num;
        }
        int res = 0;
        //遍历temp数组，寻找最晚出现的0元素的下标
        for(int i = 0; i < temp.length; i++){
            if(temp[i] == 0) res = i;
        }
       return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 时间复杂度：O(N)
• 空间复杂度：O(N)，使用到了temp数组。

思路3：位运算-异或 （O(N) O(1)）

利用异或的性质：

1. 两个相同的数字异或=0，
2. 0和其他数字做异或=数字本身

拿0~n和nums所有元素做异或，0~n和nums中相同的元素经过异或得0，最终剩下的结果就是缺失值。

例如：n=3, nums=[0,1,3]，拿0~3所有元素和nums所有元素一起做异或：(0⁰⁾(1¹⁾2⁽³3)=2，所以剩下的2就是缺失值。

//思路3：位运算
class Solution {
    public int missingNumber(int[] nums) {
        int n = nums.length;
        int res = n;
        for(int i = 0; i < n; i++){
            res = res ^ i ^ nums[i];
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11

• 时间复杂度：O(N)
• 空间复杂度：O(1)

思路4：数学 + 溢出避免（O(N) O(1)）

拿0+1+…+n之和减去nums所有元素之和，结果就是缺失值：

//没有做避免溢出处理的版本：
class Solution {
    public int missingNumber(int[] nums) {
        int n = nums.length;
        int sum = (0 + n) * (n + 1) / 2;
        int cur = 0;
        for(int num : nums){
            cur += num;
        }
        return sum - cur;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

数学方法简单，但有数据溢出的风险，为了避免数据溢出，我们可以设置一个求和变量sum，把0~n全部元素加起来的同时减去nums的所有元素，最后sum存放的就是缺失值。

//做避免溢出处理的版本：
class Solution {
    public int missingNumber(int[] nums) {
        int n = nums.length;
        int sum = 0;
        for(int i = 0; i <= n; i++){
            sum += i;
            if(i < n) sum -= nums[i];
        }
        return sum;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

• 时间复杂度：O(N)
• 空间复杂度：O(1)