剑指Offer53-Ⅱ — 0~(n-1)中缺失的数字

剑指Offer53-Ⅱ

题意

一个 长度为n-1 的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

数组中的数字范围为：0~(n-1)，该范围内共有n个数字，但是nums中只能存 (n-1)个数字，少了哪个数字呢？ n=nums.size()+1

解法1—二分

排序数组中的搜索问题，首先想到二分法解决。

根据题意，数组可以按照以下规则分为两部分：

• 左子数组： nums[i] = i ；
• 右子数组： nums[i] !​=i ；

缺失的数字等于 “右子数组的首位元素” 对应的索引；因此考虑使用二分法查找 “右子数组的首位元素”。

---

 算法解析：

1. 初始化： 左边界 i = 0，右边界 j = len(nums) - 1；代表闭区间 [i, j]。
2. 循环二分： 当 i≤j 时循环 （即当闭区间 [i, j]为空时跳出） ；
   1. 计算中点 m = (i + j) / 2；

   2. 若 nums[m] = m ，则 “右子数组的首位元素” 一定在闭区间 [m + 1, j] 中，因此执行 i = m + 1；

   3. 若 nums[m]≠m，则 “左子数组的末位元素” 一定在闭区间 [i, m - 1]中，因此执行 j = m - 1；

3. 返回值： 跳出时，变量 i 和 j 分别指向 “右子数组的首位元素” 和 “左子数组的末位元素” 。因此返回 i 即可。

复杂度分析：

• 时间复杂度 O(log N)： 二分法为对数级别复杂度。
• 空间复杂度 O(1)： 几个变量使用常数大小的额外空间。

C++实现

class Solution 
{
public:
    int missingNumber(vector<int>& nums) 
    {
        int i=0,j=nums.size()-1;    //初始化左右边界
        
        //循环二分。当i==j的时候，依然要比较，因为此时nums[i]还不知道登不等于对应的下标
        while(i<=j)
        {
            int m = i+(j-i)/2;  //计算中点
            //如果相等说明 i到 m中间肯定不少元素 所以往右边二分查找
            if(nums[m]==m)  //如果中点的值等于对应的下标，那么右子数组的首位元素肯定在[m+1,j]范围
            {
                i=m+1;
            }
            else    //中点值不等于对应的下标，那么左子数组的末尾元素肯定在[i,m-1]范围
            {
                j=m-1;
            }
        }
        return i;   //返回右子数组的首位元素的下标
    }
};

解法2—依次比较元素值与下标的关系

class Solution 
{
public:
    int missingNumber(vector<int>& nums) 
    {
        /*
        int i=0,j=nums.size()-1;    //初始化左右边界
        
        //循环二分
        while(i<=j)
        {
            int m = i+(j-i)/2;  //计算中点
            if(nums[m]==m)  //如果中点的值等于对应的下标，那么右子数组的首位元素肯定在[m+1,j]范围
            {
                i=m+1;
            }
            else    //中点值不等于对应的下标，那么左子数组的末尾元素肯定在[i,m-1]范围
            {
                j=m-1;
            }
        }
        return i;   //返回右子数组的首位元素的下标
        */

        //比较数组下标和该下标对应的值即可，再排除缺失0和缺失最后一项两个特殊情况。
        if(nums[0]==0&&nums.size()==1)
            return 1;
        for(int i=0;i<nums.size();++i)
        {
            if(nums[i]!=i)
                return i;
        }
        return nums.size();
    }
};

解法3—总和减去数组和就为缺失的数字

class Solution 
{
public:
    int missingNumber(vector<int>& nums) 
    {
        /*
        int i=0,j=nums.size()-1;    //初始化左右边界
        
        //循环二分
        while(i<=j)
        {
            int m = i+(j-i)/2;  //计算中点
            if(nums[m]==m)  //如果中点的值等于对应的下标，那么右子数组的首位元素肯定在[m+1,j]范围
            {
                i=m+1;
            }
            else    //中点值不等于对应的下标，那么左子数组的末尾元素肯定在[i,m-1]范围
            {
                j=m-1;
            }
        }
        return i;   //返回右子数组的首位元素的下标
        */

        //比较数组下标和该下标对应的值即可，再排除缺失0和缺失最后一项两个特殊情况。
        /*
        if(nums[0]==0&&nums.size()==1)
            return 1;
        for(int i=0;i<nums.size();++i)
        {
            if(nums[i]!=i)
                return i;
        }
        return nums.size();
        */

        int n =  nums.size()+1; //一共有n项，0,1,...,n-1
        int sum = n*(n-1)/2;    // 总和：n*(0+n-1)/2;
        for(int num:nums)    
            sum-=num;
        return sum;
    }
};