[Leetcode] Search for a Range

Given a sorted array of integers, 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].

Solution:

本题时间复杂度是O(log n)，暗示我们应该采用binary search的方法来做此题。

关键点在于有重复的元素，所以需要利用findMostLeft和findMostRight来找到起始和结束的位置。

  

public class Solution {
    public int[] searchRange(int[] A, int target) {
        int pos=binarySearch(A,target);
        
        if(pos==-1){
            return new int[] {-1,-1};
        }else{
            int left=-1;
            int right=-1;
            if(pos-1>=0&&A[pos]==A[pos-1]){
                left=findMostLeft(A,target,0,pos-1);           
            }
            else{
                left=pos;   
            }
            if(pos+1<=A.length-1&&A[pos]==A[pos+1]){
                right=findMostRight(A,target,pos+1,A.length-1);
                
            }else{
                right=pos;
            }
            return new int[] {left,right};
        }
    }
    public int findMostRight(int[] A,int target,int left,int right){
        
        while(left<=right){
            int mid=left+(right-left)/2;
            if(A[mid]==target){
                if(mid+1<=right&&A[mid]==A[mid+1])
                    left=mid+1;
                else
                    return mid;
            }else{
                right=mid-1;
            }
        }
        return -1;
    }
    public int findMostLeft(int[] A,int target,int left,int right){
        
        
        while(left<=right){
            int mid=left+(right-left)/2;
            if(A[mid]==target){
                if(mid-1>=left&&A[mid]==A[mid-1])
                    right=mid-1;
                else
                    return mid;      
            }else{
                left=mid+1;
            }
            mid=left+(right-left)/2;
        }
        return -1;
    }
    public int binarySearch(int[] A, int target){
        int left=0;
        int right=A.length-1;
        int mid=left+(right-left)/2;
        while(left<=right){
            
            
            if(A[mid]==target){
                
                return mid;
            }else if(A[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
            mid=left+(right-left)/2;
        }
        return -1;
    }
}