排序数组查找数字

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

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

示例 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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

　原理分析：

通过二分法分别找到左边界和右边界，从而计算出长度，按说这种解法很容易想到，但我当时第一反应还是没想到找左右边界，有时候人的思维就是这么奇妙，明明很简单，但短时间就是不往那个方向去思考，另外，小赌怡情，大赌伤身 0.0

祝各位看官都能发财！