查找有序数组中某个数下标的范围 Search for a Range

为什么80%的码农都做不了架构师？>>>   

问题：

Given an array of integers sorted in ascending order, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

解决：

① 使用折半查找，只是在找到target之后需要另外检查左右是否包含target从而找到start和end。

class Solution { //8ms
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[2]; 
        int left = 0;
        int right = nums.length - 1;
        int start = -1;
        int end = -1;
        while(left <= right){
            int mid = (right - left) / 2 + left;
            if(nums[mid] == target){
                start = mid;
                end = mid;
                while(start - 1 >= 0 && nums[start - 1] == target) start --;
                while(end + 1 < nums.length && nums[end + 1] == target) end ++;
                left = right + 1; //为了结束循环，防止超时。
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                right = mid - 1;
            }
        }
        res[0] = start;
        res[1] = end;
        return res;
    }
}

② 进化版，还是使用折半查找，但是将查找start和end分开。

class Solution {//7ms
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[]{-1, -1};
        res[0] = findStart(nums, target);
        if (res[0] == -1) return res;
        res[1] = findEnd(nums, res[0], target);
        return res;
    }
    public int findStart(int[] nums, int target) {
        int low = 0;
        int high  = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target) {//这样是为了找到第一个符合条件的下标。
                low = mid + 1;
            } else { // nums[mid] >= target
                high = mid;
            } 
        }
        if (low == high && nums[low] == target) return low;
        return -1; // not found
    }
    public int findEnd(int[] nums, int low, int target) {
        int high  = nums.length - 1;
        while (low < high) {
            int mid = (high + low) / 2 + 1; // trick part
            if (nums[mid] > target) {
                high = mid - 1;
            } else {//nums[mid] <= target，
                low = mid;
            }
        }
        if (low == high && nums[low] == target) return low;
        return -1;
    }
}

转载于:https://my.oschina.net/liyurong/blog/1528405