在排序数组中查找元素的第一个和最后一个位置

数组有序，时间复杂度要求为，使用折半查找。

一、查什么？

目标值的开始位置和结束位置，普通的折半查找只能判断目标值是否在数组当中，在的话返回其下标，但是这里面的数组有重复值，所以要对折半查找进行改造。

二、怎么查？

先查目标值的开始位置。如何定义开始位置？如果在数组中找到目标值的位置，然后判断它左边位置上的数是否和目标值相等：

如果不相等，那么此时目标值的位置就是开始位置；

如果相等的话，说明开始位置还在左边，那么把重新赋值high，在左半部分继续搜索开始位置。

查询结束位置同理，如果在数组中找到目标值的位置，然后判断它右边位置上的数是否和目标值相等，然后再重新定位low即可。

所以，需要进行两次折半查找，第一次找开始位置，第二次找结束位置。

三、代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
       final int length = nums.length;

        int[] result = new int[2];
        int start = -1,end = -1;
        result[0] = start;
        result[1] = end;

        int low = 0;
        int high = length - 1;
        int mid;
        if (length == 0){
            return result;
        }

        while (low <= high){
            mid = (low + high) / 2;
            if (nums[mid] == target){
                if (mid - 1 < 0){
                    start = mid;
                }else {
                    if (nums[mid - 1] != target){
                        start = mid;
                    }
                }
                high = mid - 1;
            }else if (nums[mid] > target){
                high = mid - 1;
            }else {
                low = mid + 1;
            }
        }
        low = 0;
        high = length - 1;

        while (low <= high){
            mid = (low + high) / 2;
            if (nums[mid] == target){
                if (mid + 1 == length){
                    end = mid;
                }else {
                    if (nums[mid + 1] != target){
                        end = mid;
                    }
                }
                low = mid + 1;
            }else if (nums[mid] > target){
                high = mid - 1;
            }else {
                low = mid + 1;
            }
        }
        result[0] = start;
        result[1] = end;

        return result;
    }
}

四、剑指offer

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int low = 0;
        int high = array.length - 1;
        int mid;
        int a = -1, b = -2;
        //1.查找左边的位置
        while (low <= high){
            mid = (low + high) / 2;
            if (array[mid] == k && (mid - 1 < 0 || array[mid - 1] != array[mid])){
                a = mid;
                break;
            }else if (array[mid] > k || array[mid] == k){
                high = mid - 1;
            }else {
                low = mid + 1;
            }
        }
        low = a == -1 ? 0 : a;
        high = array.length - 1;
        //2.查找右边的位置
        while (low <= high){
            mid = (low + high) / 2;
            if (array[mid] == k && (mid + 1 == array.length || array[mid + 1] != array[mid])){
                b = mid;
                break;
            }else if (array[mid] < k || array[mid] == k){
                low = mid + 1;
            }else {
                high = mid - 1;
            }
        }
        return b - a < 0 ? 0 : b - a + 1;
    }
}