LeetCode268.丢失的数字

268. 丢失的数字

给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

示例 1：

输入：nums = [3,0,1]
输出：2
解释：n = 3，因为有 3 个数字，所以所有的数字都在范围 [0,3] 内。2 是丢失的数字，因为它没有出现在 nums 中。
示例 2：

输入：nums = [0,1]
输出：2
解释：n = 2，因为有 2 个数字，所以所有的数字都在范围 [0,2] 内。2 是丢失的数字，因为它没有出现在 nums 中。

哈希求解

这应该是最朴素的求解方法了，用哈希表记录数组的每个元素，然后挨个判断 0 ~ n 是否在哈希表中。若哈希表中没有找到该元素，那此元素即是缺失的数字。

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        unordered_set<int> set(nums.begin(), nums.end());
        for(int i = 0; i <= nums.size(); ++i)
            if(set.count(i) == 0)
                return i;
        return -1;
    }
};

• 时间复杂度: O(N)
• 空间复杂度: O(N)
  

排序

对数组升序排序，假定没有元素缺失，那么顺序肯定是0 ~ n 顺序排布：

• 原数组: 3 2 1 0 4
• 排序后: 0 1 2 3 4
  很显然有 nums[i] == i 这一规律。
  那如果有缺失呢，需要分两种情况:
• 缺失的元素处于 [0, n - 1] 区间内，那么必然可以通过对元素挨个检查 (判断 nums[i] == i) 得出。
• 缺失的元素等于 n，也就是说 0 ~ n - 1(共n个数)都在数组中，那么数组中的元素必定都是合法的。此时可以直接返回n作为缺失的数字。

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        for(int i = 0; i < n; ++i){
            if(nums[i] != i)
                return i;
        }
        return n;
    }
};

• 时间复杂度:O(NlogN)
• 空间复杂度:O(1)
  

数学

可以先求 0 ~ n 的和sum，通过sum减去数组nums的元素和即可得到缺失的数字。
根据等差数列公式 sum = n * (n + 1) / 2。

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        int sum = n * (n + 1) / 2;
        for(int& num:nums)
            sum -= num;
        return sum;
    }
};

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

位运算

原数组的数字加上0到n(共n - 1个数字)之后，只有在数组中缺失的数字只会出现一次，打个比方: 原数组的元素为 [3, 0, 1]，缺失的数字为2，加上 0 ~ 3 之后变为了 [3, 0, 1, 0, 1, 2, 3],除缺失的数字2，其余的数字都会出现两次。
因此可以通过异或运算消除这些出现两次的元素，最终得到缺失的元素。

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        //将缺失x的数组异或一遍，再通过0 ~ n异或一遍得到缺失的数字
        int x = 0;
        int n = nums.size();
        for(int& num:nums)
            x ^= num;
        for(int i = 0; i <= n; ++i)
            x ^= i;
        return x;
    }
};

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

原地哈希

总的元素个数为n + 1，数组大小只有n，因此可以添加一个不在数组中的元素-1，使得数组大小为n + 1,
假设定义 合理 为: nums[i] == i,即当前数字等于其数组下标。
对元素进行判断，如果当前元素不合理且不等于-1，那么将该元素换到它合理的位置: swap(nums[i], nums[nums[i]]);再次进行该判断。

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

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