【Leetcode算法题】268. 丢失的数字_268.丢失的数字-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_56134369/article/details/138844381

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 中。

提示：

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

解题思路

思路一:求和做差法:

把n+1个数加起来,然后减掉数组中实际存在的n个数,剩下的就是不存在的那个数。

因为题目是找出[0, n] 这个范围内没有出现在数组中的那个数，而数组是从0-n-1,故这个数可能在0-n-1这个范围内，也可能等于n。故只要利用for循环求和,同时只要i小于数组中第i位元素，z最后sum即为在数组中没有出现的那个数。

C语言

int missingNumber(int* nums, int numsSize) {
    int sum = 0;
    for(int i = 0;i <= numsSize;i++){
        sum += i;
        if(i < numsSize){
            sum -= nums[i];
        }
    }
    return sum;
}

Java

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

Python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        n = len(nums)
        sum = 0
        for i in range(n+1):
            sum += i
            if i < n:
                sum -=nums[i]
        return sum

思路二:排序:

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

由于数组的长度是 n，因此下标范围是 [0,n−1]。假设缺失的数字是 k，分别考虑以下两种情况：

当 0≤k<n0时，对任意 0≤i<k，都有 nums[i]=i，由于 k 缺失，因此 nums[k]=k+1，k 是第一个满足下标和元素不相等的下标；

当 k=n时，0到 n−1 都没有缺失，因此对任意 0≤i<n，都有 nums[i]=i。

根据上述两种情况，就可以得出丢失的数字：

C语言

int missingNumber(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < numsSize - 1 - i; j++) {
            if (nums[j] > nums[j + 1]) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
    for(int i = 0;i <numsSize;i++){
        if(nums[i] != i){
            return i;
        }
    }
    return numsSize;
}

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;
    }
}

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)

思路三:位运算:

利用异或运算求解。
相同为0，不同为1.
使用一个for循环来让从0-numSize-1的数与num[]的元素异或。

C语言

int missingNumber(int* nums, int numsSize){
    int result=numsSize;
    for(int i=0;i<numsSize;i++){
        result^=i^nums[i];
    }
    return result;
}

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;
    }
}

Python

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        result = 0
        for i, num in enumerate(nums):
            result ^= i ^ num
        return result ^ len(nums)

思路四:哈希集合:

首先遍历数组 nums，将数组中的每个元素加入哈希集合，然后依次检查从 0 到 n 的每个整数是否在哈希集合中，不在哈希集合中的数字即为丢失的数字。

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;
    }
}

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