【LeetCode】34. Search for a Range

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].

     题目大意为在一个整型数组中找出某个数第一次出现和最后一次出现的下标，若未找到则返回[-1,-1]，要求时间复杂度为O(log n)。这道题要求时间复杂度为O(log n)自然就想到了要用分治法。先分解，将这个整形数组从中间一分为二，若中间的值大于target，则去较小的那一半继续循环，否则进入大的那一半，直至找到结果（类似与二分法查找），再从结果分别想前后延伸，找出第一次出现和最后一次出现的位置。这道题的思路还是比较容易想到的，但是边界的处理有点复杂，递归实现的代码如下：

    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1,-1};
        if(nums.length==0) return result;
        solve(nums,target,0,nums.length-1,result);
        return result;
    }
    public int[] solve(int[] nums,int target,int begin,int end,int[] result){
        if (begin >= end&&nums[(begin+end)/2]!=target) return result;//没有符合的结果
        if(nums[(begin+end)/2]==target){
            int i=(begin+end)/2,j=(begin+end)/2,flag=0;
            while(nums[i]==target&&i>0){
                i--;
                flag=1;
            }
            if(i==0&&nums[i]==target){//处理边界问题
                i--;
                flag=1;
            }
            result[0]=flag==1?i+1:i;
            while(nums[j]==target&&j<nums.length-1){
                j++;
                flag=2;
            }
            if(j==nums.length-1&&nums[j]==target){
                j++;
                flag=2;
            }
            result[1]=flag==2?j-1:j;
            return result;
        }else if(nums[(begin+end)/2]>target){
            return solve(nums,target,begin,(begin+end)/2,result);
        }else{
            return solve(nums,target,(begin+end)/2+1,end,result);
        }
    }

       因为处理边界的问题，使代码显得有些臃肿，但所幸运行速度还是挺快的。下面在附上大神用循环做的代码，更为简洁：

    public int[] searchRange(int[] A, int target) {
		int start = Solution.firstGreaterEqual(A, target);
		if (start == A.length || A[start] != target) {
			return new int[]{-1, -1};
		}
		return new int[]{start, Solution.firstGreaterEqual(A, target + 1) - 1};
	}

	//find the first number that is greater than or equal to target.
	//could return A.length if target is greater than A[A.length-1].
	//actually this is the same as lower_bound in C++ STL.
	private static int firstGreaterEqual(int[] A, int target) {
		int low = 0, high = A.length;
		while (low < high) {
			int mid = low + ((high - low) >> 1);
			//low <= mid < high
			if (A[mid] < target) {
				low = mid + 1;
			} else {
				//should not be mid-1 when A[mid]==target.
				//could be mid even if A[mid]>target because mid<high.
				high = mid;
			}
		}
		return low;
	}