剑指offer 面试题53 在排序数组中查找数字

问题1：统计一个数字在排序数组中出现的次数。

输入：数组

输出：次数

思路：

由于在排序数组中，可以使用二分查找。（注意加1减1细节。）

代码：

class Solution {
public:
    int getFirst(vector<int>& nums, int target,int len,int start,int end)
    {
        if(start>end)
            return -1;
        int indexMiddle=(start+end)>>1;
        int dataMiddle=nums[indexMiddle];
        if(target==dataMiddle)
        {
            if((indexMiddle>0&&nums[indexMiddle-1]<target)||indexMiddle==0)
                return indexMiddle;
            else
                end=indexMiddle-1;   // -1 +1 的关键作用：能够使递归有出口
        }
        else if(target<dataMiddle)
        {
            end=indexMiddle-1;
        }
        else
        {
            start=indexMiddle+1;
        }
        return getFirst(nums,target,len,start,end);
    }

    int getLast(vector<int>& nums, int target,int len,int start,int end)
    {
        if(start>end)
            return -1;
        int indexMiddle=(start+end)>>1;
        int dataMiddle=nums[indexMiddle];
        if(dataMiddle==target)
        {
            if((indexMiddle<len-1&&nums[indexMiddle+1]>target)||indexMiddle==len-1)
                return indexMiddle;
            else
                start=indexMiddle+1;
        }
        else if(target>dataMiddle)
            start=indexMiddle+1;
        else
            end=indexMiddle-1;
        return getLast(nums,target,len,start,end);
    }
    int GetNumberOfK(vector<int>& nums, int target) {
        int len=nums.size();
        if(len==0)
            return 0;
        int start=getFirst(nums,target,len,0,len-1);
        int end=getLast(nums,target,len,0,len-1);
        if(start>-1&&end>-1)
            return end-start+1;
        else
            return 0;
    }
};

复杂度分析：时间复杂度为O(logn)，空间复杂度为O(1)。

问题2：0～n-1中缺失的数字

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

思路：由于是有序数组，使用二分查找寻找第一个值与下标不相等的值。

代码：

class Solution {
public:
    int getFirst(vector<int>& nums, int len, int start, int end)
    {
        while(start<=end)
        {
            int middle=(start+end)>>1;
            if(nums[middle]!=middle){
                if(middle==0||nums[middle-1]==middle-1)
                    return middle;
                else
                    end=middle-1;
            }    
            else
                start=middle+1;
        }
        if(start==len)
            return len;
        else
            return -1;
    }
    int missingNumber(vector<int>& nums) {
        int len=nums.size();
        return getFirst(nums,len,0,len-1);
    }
};

复杂度分析：时间复杂度为O(logn)，空间复杂度为O(1)。