思路:
既然要求时间复杂度为O(log n),首先想到的自然是用折半查找法。我的思路是用递归先找到开始位置(即最左边的位置),然后再找到结束位置(即最右边的位置)即可。
实现:
public class Solution {
public int[] searchRange(int[] A, int target) {
return new int[]{findLeft(A, target, 0, A.length - 1) ,findRight(A, target, 0, A.length - 1)};
}
public int findLeft(int[] A, int target,int start, int end) {
if(start > end)
return -1;
int middle = (start + end) / 2;
if(target == A[middle]) {
if(middle == 0 || target != A[middle - 1])
return middle;
else
return findLeft(A, target, start, middle - 1);
} else if(target > A[middle])
return findLeft(A, target, middle + 1, end);
else
return findLeft(A, target, start, middle - 1);
}
public int findRight(int[] A, int target,int start, int end) {
if(start > end)
return -1;
int middle = (start + end) / 2;
if(target == A[middle]) {
if(middle == A.length - 1 || target != A[middle + 1])
return middle;
else
return findRight(A, target, middle + 1, end);
} else if(target > A[middle])
return findRight(A, target, middle + 1, end);
else
return findRight(A, target, start, middle - 1);
}
}
后来在网上看到了另外一种思路,先用折半查找法找到与target相等的数字,然后再往前后找范围,我感觉这个思路碰到极端情况会超时,但是试着实现了一下也正常通过了。
public class Solution {
public int[] searchRange(int[] A, int target) {
int start = 0;
int end = A.length - 1;
int pos = find(A, target, start, end);
if(pos == -1)
return new int[]{-1, -1};
for(int i = pos - 1; i >= 0; i--) {
if(target != A[i]) {
start = ++i;
break;
}
}
for(int i = pos + 1; i <= end; i++) {
if(target != A[i]) {
end = --i;
break;
}
}
return new int[]{start, end};
}
public int find(int[] A, int target, int start, int end) {
if(start > end)
return -1;
int mid = (end + start) / 2;
if(target == A[mid]) {
return mid;
}
if(target > A[mid]) {
return find(A, target, mid + 1, end);
} else {
return find(A, target, start,mid - 1);
}
}
}
由于个人水平有限、算法接触不多,代码写得有些水,不过重在坚持,所以在此记录一下,也算是对自己的一种督促,希望能坚持下去!