数字在排序数组中出现的次数

思路1

这道题让我们在一个有序整数数组中寻找相同目标值的起始和结束位置，而且限定了时间复杂度为O(logn)，这是典型的二分查找法的时间复杂度，所以这道题我们也需要用此方法，我们的思路是首先对原数组使用二分查找法，找出其中一个目标值的位置，然后向两边搜索找出起始和结束的位置，代码如下：

    //先找到一个目标值的位置，再左右搜索找到起始位置
    public int[] searchRange(int arr[],int target) {
        int index = search(arr,0,arr.length,target);
        if(index == -1) return new int[]{-1,-1};
        int left = index , right = index;
        while(left > 0&&arr[left-1]==arr[index]) --left;
        while(right < arr.length && arr[right+1] == arr[index]) ++right;
        return new int[] {left,right};
    }

    private int search(int[] arr, int left, int right, int target) {
        if(left >right) return -1;
        int mid = left+(right - left)/2;
        if(arr[mid] == target) 
            return mid;
        else if(arr[mid]<target) 
            return search(arr, mid+1, right, target);
        else 
            return search(arr, left, mid-1, target);
    }

思路2

可能有些人会觉得上面的算法不是严格意义上的O(logn)的算法，因为在最坏的情况下会变成O(n)，比如当数组里的数全是目标值的话，从中间向两边找边界就会一直遍历完整个数组，那么我们下面来看一种真正意义上的O(logn)的算法，使用两次二分查找法，第一次找到左边界，第二次调用找到右边界即可，重新实现lower_bound 和upper_bound。

    //二分查找法：第一次找到左边界，第二次找到右边界，即实现 lower_bound 和 upper_bound
    // 时间复杂度O(logn)，空间复杂度O(1)
    public int[] searchRange2(int[] nums, int target) {
        int lower = lower_bound(nums, 0, nums.length, target);
        int upper = upper_bound(nums, 0, nums.length, target);
        if (lower == nums.length || nums[lower] != target)
            return new int[]{-1, -1};
        else
            return new int[]{lower, upper-1};
    } 
    //lower_bound找到左边界
    public int lower_bound (int[] A, int first, int last, int target) {
        while (first != last) {
            int mid = first + (last - first) / 2;
            if (target > A[mid]) first = ++mid;
            else last = mid;
        } 
        return first;
    }
    //upper_bound找到右边界
    public int upper_bound (int[] A, int first, int last, int target) {
        while (first != last) {
            int mid = first + (last - first) / 2;
            if (target >= A[mid]) first = ++mid; // 与 lower_bound 仅此不同
            else last = mid;
        } 
        return first;
    }