题目描述
给定一个包含 [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;
}