leetcode第268题——丢失的数字（C语言实现）

题目描述

给定一个包含 [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 中的所有数字都 独一无二
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/missing-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

题目分析：
给定你一个数组，数组的长度就是numsSize，并且数字的范围应该在0-numsSize之间，现在有一个nums，去判断nums中少了那一个数字。

代码如下：

int missingNumber(int* nums, int numsSize){
    quickSort(nums,0,numsSize - 1);
    for(int i = 0;i < numsSize;i++){
        if(i != nums[i]){
            return i;
        }
    }
    return numsSize;
}
//快速排序
void quickSort(int arr[], int low, int high)
{
    int first = low;
    int last  = high;
    int key = arr[first];
    if(low >= high)
        return;
    while(first < last)
    {
        while(first < last && arr[last] > key)
        {
            last--;
        }
        arr[first] = arr[last];

        while(first < last && arr[first] < key)
        {
            first++;
        }
        arr[last] = arr[first];
    }
    arr[first] = key;

    quickSort(arr, low, first-1);
    quickSort(arr, first+1, high);
}

大体的思路就是，先用快速排序把整个数组进行重新的排序，例如，假设数组为【3，0，1】，那么numsSize为3，应该是0-3，这样很明显少了一个2，排序之后为0,1，3那么，再依次遍历数组元素的过程中，当i=2时，对应的是3，那么说明2是少的那一个元素。再就是注意一个问题，如果是0,1，那么少的元素是2，最后返回numsSize即可。

提交三次为什么失败存在的问题

第一次提交【题目没有阅读清楚】

代码如下：

int missingNumber(int* nums, int numsSize){
    int tag = 0;
    for(int i = 0;i < numsSize;i++){
        tag = 0;
        for(int j = 0;j < numsSize;j++){
            if(nums[j] == i)//第一趟我就找i = 0 如果能找到，那么我就进下一趟循环 如果找不到，//那么肯定是缺少的元素
            tag = 1;
        }
        if(tag == 0)//说明没找到这个元素，那我返回这个元素
        return i;
        //nums = [0,1]  为什么会是n = 2  我很疑惑
    }
    return -1;
}

这里犯得错误就是，我以为是给定的数组中的最大元素才是n，例如他给的0,1。我以为n是1，就导致这个实例输出的一直是-1。

第二次提交【超时】

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

这里我想到的是，第一趟就找0，第二趟就找1，依次类推，只要有找不到的，那么必定是缺失元素。所以我把i的范围设置为0-numsSize，看起来可能没问题，但是超时了

第三次提交【冒泡排序也超时】

int missingNumber(int* nums, int numsSize){
    //数组的范围应该在0 - numsSize之间 从这里面找那个数不存在
    int temp;
    for(int i = 0;i < numsSize-1;i++){
        for(int j = 0; j < numsSize - i - 1;j++){
            if(nums[j] > nums[j+1]){
                temp = nums[j+1];
                nums[j+1] = nums[j];
                nums[j] = temp;
            }
        }
    }
    for(int i = 0;i < numsSize;i++){
        if(i != nums[i]){
            return i;
        }
    }
    return numsSize;
}

这里考虑的是冒泡排序，已经与主流思路很接近了，就是先把数组排序一遍，然后再挨个对应，对应不上的是缺失，全部对应的应该是缺失numsSize。
但是要考虑到冒泡排序的时间复杂度平均情况下也是平方量级的，所以其实与第二次提交没什么区别，所以最后还是用到了快速排序，其实快速排序的时间复杂度为O(nlogn),但是由于用的是递归，空间复杂度也很高。

下面分享一个数学思维解法（我是想不到0.0）

思路是这样的，假设数组【3，0，1】，我们都知道求一个n个数的和的公式是n*(n+1)/2。我们先求出0-numsSize的和。这里应该是3*4/2=6。然后我们再求出已知的数组和，3+0+1=4。二者相减6-4=2 就是我们要求的缺少的那个数字，提交的代码如下:

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