【leetcode】Array——Search for a Range（34）

题目：

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]

.

思路：还是经典的binary search，如果nums[mid]==target，从mid出发，向左右遍历，找范围。但要注意可能会出现out of array range

代码：

public int[] searchRange(int[] nums, int target) {
int left=0,right=nums.length-1;
int [] results = new int [2];
while(left<=right){
int mid = (left+right)/2;
if(nums[mid]==target){
//search left range
int lefttemp = mid;
while(nums[lefttemp]==target)
{
lefttemp--;
if(lefttemp==-1)
break;
}
results[0]=lefttemp+1;
//search right range
int righttemp = mid;
while(nums[righttemp]==target)
{
righttemp++;
if(righttemp==nums.length)
break;
}
results[1]=righttemp-1;
return results;
}
if(target<nums[mid])
right = mid-1;
else
left = mid +1;
}
//如果没有在循环里面内return，说明没有匹配到target，返回[-1,-1]
results[0]=results[1]=-1;
return results;
}

虽然，AC了，但是细想时间复杂度并不是 O(log n)。例如，[1,1,1,1,1,1,1,1]，这时候是O(n)。

改进思路1：用binary search查找第一个大于或者等于target的位置，则结果为[ firstGreaterEqual(target), firstGreaterEqual(target+1)-1]

public class Solution {
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;
}
}

leetcode链接：https://leetcode.com/discuss/19368/very-simple-java-solution-with-only-binary-search-algorithm

改进思路2：分别用binary search查找target第一次出现的位置和最后出现的位置，binary内部的细节很重要，主要是当nums[mid]==target的时候，是向左还是向右，决定了是第一次出现还是最后出现的位置。

public class Solution {
public int[] searchRange(int[] nums, int target) {
int[] result = new int[2];
result[0] = findFirst(nums, target);
result[1] = findLast(nums, target);
return result;
}

private int findFirst(int[] nums, int target){
int idx = -1;
int start = 0;
int end = nums.length - 1;
while(start <= end){
int mid = (start + end) / 2;
if(nums[mid] >= target){
end = mid - 1;
}else{
start = mid + 1;
}
if(nums[mid] == target) idx = mid;
}
return idx;
}

private int findLast(int[] nums, int target){
int idx = -1;
int start = 0;
int end = nums.length - 1;
while(start <= end){
int mid = (start + end) / 2;
if(nums[mid] <= target){
start = mid + 1;
}else{
end = mid - 1;
}
if(nums[mid] == target) idx = mid;
}
return idx;
}

leetcode链接：https://leetcode.com/discuss/52701/easy-java-o-logn-solution点击打开链接