LeetCode--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 中。
示例 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 中。

1、数学

首项以1开始，长度结束，乘以项数，除以2，然后减去数组的和

时间复杂度：O（N），数组求和

空间复杂度：O（1），没有使用额外空间

python：

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

java：

class Solution {
    public int missingNumber(int[] nums) {
        int sum = 0;
        for (int num : nums) {
            sum = sum + num;
        }
        return (nums.length + 1) * nums.length / 2 - sum;
    }
}

go：

func missingNumber(nums []int) int {
    sum := 0
    for _, v := range nums {
        sum += v
    }
    return (len(nums) + 1) * len(nums) / 2 - sum
}

2、排序

将数组排序之后，即可根据数组中每个下标处的元素是否和下标相等，得到丢失的数字。

时间复杂度：O（nlogn），排序

空间复杂度：O（logn），排序

python：

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

java：

class Solution {
    public int missingNumber(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (nums[i] != i) {
                return i;
            }
        }
        return n;
    }
}

go：

func missingNumber(nums []int) int {
    sort.Ints(nums)
    for i, v := range nums {
        if i != v {
            return i
        }
    }
    return len(nums)
}

3、哈希

使用哈希集合，可以将时间复杂度降低到 O(n)。

首先遍历数组 nums，将数组中的每个元素加入哈希集合，然后依次检查从 0 到 n 的每个整数是否在哈希集合中，不在哈希集合中的数字即为丢失的数字。由于哈希集合的每次添加元素和查找元素的时间复杂度都是 O(1)，因此总时间复杂度是 O(n)。

时间复杂度：O（N）

空间复杂度：O（N）

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

java：

class Solution {
    public int missingNumber(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            set.add(nums[i]);
        }
        int missing = -1;
        for (int i = 0; i <= n; i++) {
            if (!set.contains(i)) {
                missing = i;
                break;
            }
        }
        return missing;
    }
}

go：

func missingNumber(nums []int) int {
    hashmap := make(map[int]int)
    for _, v := range nums {
        if _, ok := hashmap[v]; ok {
            hashmap[v] += 1
        } else {
            hashmap[v] = 1
        }
    }
    for i := 0; i <= len(nums); i++ {
        if _, ok := hashmap[i]; !ok {
            return i
        }
    }
    return -1
}