排序数组查找数字

今天实验室同学让我做一道力扣上标记的简单题，题目描述如下：

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

示例 1:

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

同学跟我说只要我能用低于o(n)时间复杂度的解法做出来就给一瓶牛奶，于是我看完题目后一口气写出如下代码：

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

　原理如下：先使用二分查找定位目标值，再从目标值左右开弓搜索，是不是有点像中心扩展法

如果按照平均时间复杂度来说，其实还是O(n)级别，并没有比暴力解法好到哪里去，顶多好那么一点点，但他还是送了一瓶牛奶给我，哈哈哈！

下面给出官方解法：

class Solution {
public:
    int binarySearch(vector<int>& nums, int target, bool lower) {
        int left = 0, right = (int)nums.size() - 1, ans = (int)nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }
 
    int search(vector<int>& nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target) {
            return rightIdx - leftIdx + 1;
        }
        return 0;
    }
};
 
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/solution/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-wl6kr/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。