LeetCode:268. 丢失的数字开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第1天，点击查

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第1天，点击查看活动详情

268. 丢失的数字

来源：力扣（LeetCode）链接：leetcode-cn.com/problems/mi…

给定一个包含 [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 中。

示例 3：

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

示例 4：

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

提示：

n == nums.length 1 <= n <= 104 0 <= nums[i] <= n nums 中的所有数字都独一无二

进阶：

你能否实现线性时间复杂度、仅使用额外常数空间的算法解决此问题?

解法

先排序后遍历：如果此时的index值与元素值不一致，表明缺该index值，如果遍历完都不缺，则缺n值（长度）
python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        for i in range(n):
            if i != nums[i]:
                return i
        return n

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

集合+遍历：将nums转化成集合，然后遍历，如果index不在集合中，则返回该index
python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        s = set(nums)
        for i in range(len(nums)+1):
            if i not in s:
                return i

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        unordered_set<int> set;
        int n = nums.size();
        for (int i=0; i<n; i++)
        {
            set.insert(nums[i]);
        }
        int missing = -1;
        for(int i=0; i<n+1; i++)
        {
            if(!set.count(i))
            {
                missing = i;
                break;
            }
        }
        return missing;
    }
};

数学求和作差：由于是等差数列，可以用求和公式求得结果，之后再减去元素列表和，差就是差的元素
python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        total = n*(n+1)//2
        return total - sum(nums)

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

异或： x ^ x = 0 x^0 = x，如果给元素列表添加一个没有少数字的列表，元素直接互相异或，剩余的那个值就是少的元素
python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        for i in range(n+1):
            nums.append(i)  # 先加元素再异或
        ans = 0 
        for i in range(len(nums)):
            ans ^= nums[i]
        return ans

'''
class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        ans = 0
        for i in range(n):
            ans ^= nums[i]
        for i in range(n+1):  # 知道要异或的元素是什么，可以不用加进去，缩短遍历长度
            ans ^= i
        return ans
 '''

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int n = nums.size();
        int ans = 0;
        for(int i=0; i< n; i++)
        {
            ans ^= nums[i];
        }
        for (int i=0; i<= n; i++)
        {
            ans ^= i;
        }
        return ans;

    }
};

复杂度分析

时间复杂度：
- 方法1: $O(logn)$ 排序占用时间
- 方法2: $O(n)$ 构建哈希集合占用时间
- 方法3: $O(n)$ 求和占用时间
- 方法4: $O(n)$ 遍历占用时间
空间复杂度：
- 方法1: $O(logn)$ ,递归排序时候占用的空间
- 方法2： $O(n)$ 哈希集合占用空间
- 方法3: $O(1)$
- 方法4: $O(1)$