leecode-C语言实现-268. 丢失的数字

一、题目
给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数。

二、解题思路
（1）代码1思路
双重循环，外层为循环次数，里层为需要遍历的数组，用一个中间变量值进行比较，注意中间变量要初始化为数组的第一个元素。外层循环一次，中间变量需要减一。遍历数组时，数组中的元素和中间变量一致，表示数组中存在中间变量，这时跳出循环，后面的元素没有必要再进行遍历。

（2）代码2思路
临时数组：表示里面的数据有序且间隔为1，当测试数组长度为4时，临时数组为{0，1，2，3}。
测试数组:为给定的数组，X表示占位符，容易理解使用。
临时数组之和减去测试数组之和的绝对值，其实就是4比1大多少，也就是测试数组中的最大值4比除最大值4外临时数组中多的1大多少。最大值减去差值就是缺少的值。
下面是几个例子可以参考一下是不是上面的这个规律。

测试数组长度 ：4
测试数组 ：0 X 2 3 4
临时数组 ：0 1 2 3
数组和差值 ：3

测试数组长度 ：4
测试数组 ：0 1 X 3 4
临时数组 ：0 1 2 3
数组和差值 ： 2

测试数组长度 ：3
测试数组 ： X 1 2 3
临时数组 ： 0 1 2
数组和差值 ： 3

测试数组长度 ： 2
测试数组 ： X 1 2
临时数组 ： 0 1
数组和差值 ： 2

（3）代码3思路
临时数组：表示里面的数据有序且间隔为1，当测试数组长度为4时，临时数组为
{0，1，2，3，4}。
测试数组:为给定的数组，X表示占位符，容易理解使用。
临时数组之和减去测试数组之和的结果为缺少的值。
下面是几个例子可以参考一下是不是上面的这个规律。

测试数组长度 ：4
测试数组 ：0 X 2 3 4
临时数组 ：0 1 2 3 4
数组和差值 ：1

测试数组长度 ：4
测试数组 ：0 1 X 3 4
临时数组 ：0 1 2 3 4
数组和差值 ： 2

测试数组长度 ：3
测试数组 ： X 1 2 3
临时数组 ： 0 1 2 3
数组和差值 ： 0

测试数组长度 ： 2
测试数组 ： X 1 2
临时数组 ： 0 1 2
数组和差值 ： 0

三、虚机模拟测试代码

#include <stdio.h>
#include <stdlib.h>
#define SIZE 2

void main()
{
    int missingNumber_v0(int* nums, int numsSize);
    int missingNumber_v1(int* nums, int numsSize);
    int missingNumber(int* nums, int numsSize);
  
    int result,result_1,result_2;
    int array[SIZE] = {1,2};

    result = missingNumber_v0(array,SIZE);
    result_1 = missingNumber_v1(array,SIZE);
    result_2 = missingNumber(array,SIZE);
    printf("result   : %d\n",result);
    printf("result_1 : %d\n",result_1);
    printf("result_2 : %d\n",result_2);
}

int missingNumber_v0(int* nums, int numsSize)
{
    int i , j , flag;
    int tmp = numsSize;

    for(j=0;j<numsSize;j++)
    {
        flag = 1;
        for(i=0;i<numsSize;i++)
        {
            if(nums[i] == tmp)
            {
                flag = 0;
                break;
            }
        }
        if(flag)
        {
            return tmp;
        }
        tmp--;
    }
    return 0;    
}

int missingNumber_v1(int* nums, int numsSize)
{
    int sum(int num);
    int max(int *array, int size);

    int sum_res = sum(numsSize);
    int i;
    int tmp = 0;

    for(i=0;i<numsSize;i++)
    {
        tmp = tmp + nums[i];
    }

    if(tmp == sum_res)
    {
        return numsSize;
    }
    else
    {
        return max(nums,numsSize) - (abs(tmp - sum_res));
    } 
}

int max(int *array, int size)
{
    int i;
    int max = array[0];
    for(i=0;i<size;i++)
    {
        if(max < array[i])
        {
            max = array[i];
        }
    }
    return max;
}

int sum(int num)
{
    int i;
    int sum = 0;

    for(i=0;i<num;i++)
    {
        sum = sum + i;
    }
    return sum;
}

int missingNumber(int* nums, int numsSize)
{
    int array_sum = 0;
    int tmp_sum = 0;
    int max_num = nums[0];
    int i;

    for(i=0;i<numsSize;i++)
    {
        if(max_num < nums[i])
        {
            max_num = nums[i];
        }

        array_sum = array_sum + nums[i];
        tmp_sum = tmp_sum + i;
    }
  
    if(tmp_sum == array_sum)
    {
        return numsSize;
    }
    printf("max_num : %d , tmp_sum : %d , array_sum : %d\n",max_num,tmp_sum,array_sum);
    return abs(max_num - abs(tmp_sum - array_sum));
}

int missingNumber_learn(int* nums, int numsSize)
{
    int array_sum = 0;
    int tmp_sum = 0;
    int i;

    for(i=0;i<numsSize;i++)
    {
        array_sum = array_sum + nums[i];
        tmp_sum = tmp_sum + i;
    }

    tmp_sum += i;

    return tmp_sum - array_sum;
}

四、虚机模拟测试截图

五、leecode提交源码
（1）提交版本1

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

（2）提交版本2

int missingNumber(int* nums, int numsSize)
{
    int sum(int num);
    int max(int *array, int size);

    int sum_res = sum(numsSize);
    int i;
    int tmp = 0;
    int max_res = max(nums,numsSize);

    for(i=0;i<numsSize;i++)
    {
        tmp = tmp + nums[i];
    }

    if(tmp == sum_res)
    {
        return numsSize;
    }
    else
    {
        return max_res - (abs(tmp - sum_res));
    }
}

int max(int *array, int size)
{
    int i;
    int max = array[0];
    for(i=0;i<size;i++)
    {
        if(max < array[i])
        {
            max = array[i];
        }
    }
    return max;
}

int sum(int num)
{
    int i;
    int sum = 0;

    for(i=0;i<num;i++)
    {
        sum = sum + i;
    }
    return sum;
}

（3）提交版本3

int missingNumber(int* nums, int numsSize)
{
    int array_sum = 0;
    int tmp_sum = 0;
    int max_num = nums[0];
    int i;

    for(i=0;i<numsSize;i++)
    {
        if(max_num < nums[i])
        {
            max_num = nums[i];
        }

        array_sum = array_sum + nums[i];
        tmp_sum = tmp_sum + i;
    }
  
    if(tmp_sum == array_sum)
    {
        return numsSize;
    }
    //printf("max_num : %d , tmp_sum : %d , array_sum : %d\n",max_num,tmp_sum,array_sum);
    return abs(max_num - abs(tmp_sum - array_sum));
}

六、leecode提交截图