2021.5.20 剑指 Offer 53 - I 在排序数组中查找数字 I（二分法查询某个数字第一次出现的位置）

注：

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

示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

限制：
0 <= 数组长度 <= 50000

题解：
方法一 两次二分寻找左右边界
解题思路：
排序数组中的搜索问题，首先想到 二分法 解决。

排序数组 nums 中的所有数字 target 形成一个窗口，记窗口的 左 / 右边界 索引分别为 left 和 right ，分别对应窗口左边 / 右边的首个元素。

本题要求统计数字 target 的出现次数，可转化为：使用二分法分别找到 左边界 left 和 右边界 right ，易得数字 target 的数量为 right - left - 1 。

算法解析：
初始化： 左边界 i = 0 ，右边界 j=len(nums)−1 。
循环二分： 当闭区间 [i, j] 无元素时跳出；
计算中点 m = (i + j) / 2 （向下取整）；
若 nums[m] < target ，则 target 在闭区间 [m+1,j] 中，因此执行 i = m + 1；
若 nums[m]>target ，则 target 在闭区间 [i,m−1] 中，因此执行 j = m - 1；
若 nums[m] = target ，则右边界 right 在闭区间 [m+1,j] 中；左边界 left 在闭区间 [i,m−1] 中。因此分为以下两种情况：
若查找 右边界 right ，则执行 i=m+1 ；（跳出时 i 指向右边界）
若查找 左边界 left ，则执行 j=m−1 ；（跳出时 j 指向左边界）
返回值： 应用两次二分，分别查找 right 和 left ，最终返回 right - left - 1 即可。

效率优化：
以下优化基于：查找完右边界 right = i 后，则nums[j] 指向最右边的 target （若存在）。

查找完右边界后，可用nums[j]=j 判断数组中是否包含 target ，若不包含则直接提前返回 0 ，无需后续查找左边界。

查找完右边界后，左边界 left 一定在闭区间 [0,j] 中，因此直接从此区间开始二分查找即可。

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

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.size()==0){
            return 0;
        }
        //二分法的查找范围
        int left=0;
        int right=nums.size()-1;
        //目标值的左右边界
        int start;
        int end;
        //查找左边界，这边是“小于等于”，因此当循环结束后，left和right不重合，且如果存在target值的话，right的位置就是左边界，因为最后一次循环一定是nums[mid]==target，此时right=mid-1，即right指向target
        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]<target){
                left=mid+1;
            }
            else{
                right=mid-1;
            }
        }
        start=right;
        //判断是否存在target
        if(left<nums.size()&&nums[left]!=target){
            return 0;
        }
        //查找右边界
        left=0;
        right=nums.size()-1;
        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]>target){
                right=mid-1;
            }
            else{
                left=mid+1;
            }
        }
        end=left;
        return end-start-1;
    }
};

方法二 一次二分

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.size()==0){
            return 0;
        }
        int left=0;
        int right=nums.size()-1;
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[left]==target&&nums[right]==target){
                break;
            }
            else{
                if(nums[mid]<target){
                    left=mid+1;
                }
                else if(nums[mid]>target){
                    right=mid-1;
                }
                else{
                    if(nums[left]!=target){
                        left++;
                    }
                    if(nums[right]!=target){
                        right--;
                    }
                }
            }
        }
        return nums[left]==target?right-left+1:0;
    }
};