Search for a Range
https://leetcode.com/problems/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].
解题思路：
看到O(logn)，就知道这题仍然是比较典型的二分查找。二分查找想要写正确的关键就在于把握分类的原则，就是方法内部所有分支都没有交集，但所有分支加起来又正好是全集。这个原则非常关键，有助于写出清晰的程序。前面讲过，如果前者违背了，可能导致mid被多次更新，有些区间就搜不到了；后者被违背可能搜到无法更新start或end的区间，引起死循环。我们来看看这道题目。
A[mid]大于或者小于taget的情况下，去搜另一边，这个和普通的二分查找没什么区别。问题是，如果A[mid]==target，就能return吗？这里是不行的，必须分别往两边搜，找出target可能的最大区域。但是，这时已经可以更新区域的边界值了，这里用一个int[] result来记录。分别存储mid的最大和最小值即可。但是注意第一次更新最小值的时候不能直接Math.min(result[0], mid)，因为-1永远最小，必须强行更新。
递归终止的条件是start > end。
有了上面的思路，这段代码可以非常清晰的写出，一次AC，鼓舞人心啊。刷题到现在可以感觉自己的coding能力在提高。
public class Solution { public int[] searchRange(int[] A, int target) { int[] result = new int[]{-1, -1}; searchRangeHelper(A, 0, A.length - 1, target, result); return result; } public void searchRangeHelper(int[] A, int start, int end, int target, int[] result){ int mid = start + (end - start) / 2; if(start > end){ return; } if(A[mid] < target){ searchRangeHelper(A, mid + 1, end, target, result); } if(A[mid] > target){ searchRangeHelper(A, start, mid - 1, target, result); } if(A[mid] == target){ if(result[0] == -1){ result[0] = mid; }else{ result[0] = Math.min(result[0], mid); } result[1] = Math.max(result[1], mid); searchRangeHelper(A, start, mid - 1, target, result); searchRangeHelper(A, mid + 1, end, target, result); } } }
下面是网上有人给出的算法，方法和我的一样，为什么贴出来呢？是因为它用了递归，但其实思路是比较混乱的，因为递归内部还用了循环。循环一般是迭代时候采用的退出条件，而递归一般在进入方法的时候判断，如果l<=r的时候就return了。所以他这不是一个好方法，贴出来纯粹为了举反例，告警自己。
public class Solution { public int[] searchRange(int[] A, int target) { int[] ans = new int[]{-1,-1}; searchRange(A, target, 0, A.length-1, ans); return ans; } private void searchRange(int[] A, int target, int start, int end, int[] ans){ if(end<start) return; int l =start, r = end, mid; while(l<=r){ mid = l+(r-l)/2; if(A[mid]==target){ ans[0] = (ans[0]>=0)? Math.min(ans[0],mid):mid; ans[1] = Math.max(ans[1],mid); searchRange(A,target,l,mid-1,ans); searchRange(A,target,mid+1,r,ans); return; } else if(A[mid]>target) r = mid-1; else l = mid+1; } return; } }
回头说这道题的解法，二分查找可以用递归可以用迭代，一般简单的我们都用迭代，可是为什么这道题用递归？因为A[mid] == target的时候，需要分别去两边搜索，这时递归就能写出比较清晰的思路。那么用迭代如何去实现呢？两次二分查找。第一次找range的最左边界，第二次找最右边界。
public class Solution { public int[] searchRange(int[] A, int target) { int[] result = new int[]{-1, -1}; int start = 0; int end = A.length - 1; while(start <= end){ int mid = start + (end -start) / 2; if(A[mid] < target){ start = mid + 1; }else if(A[mid] > target){ end = mid - 1; }else{ if(result[0] == -1){ result[0] = mid; }else{ result[0] = Math.min(result[0], mid); } result[1] = Math.max(result[1], mid); //找最左边界 end = mid - 1; } } start = 0; end = A.length - 1; while(start <= end){ int mid = start + (end -start) / 2; if(A[mid] < target){ start = mid + 1; }else if(A[mid] > target){ end = mid - 1; }else{ if(result[0] == -1){ result[0] = mid; }else{ result[0] = Math.min(result[0], mid); } result[1] = Math.max(result[1], mid); //找最右边界 start = mid + 1; } } return result; } }
继续优化，第一次更新最左边界，那么只要更新result[0]就可以了。第二次更新最右边界，再去更新result[1]。而且第二次只需要在result[0]到A.length - 1的区间内去搜索右边界即可。但是要注意，如果result[0]==-1，则要从0开始。
public class Solution { public int[] searchRange(int[] A, int target) { int[] result = new int[]{-1, -1}; int start = 0; int end = A.length - 1; while(start <= end){ int mid = start + (end -start) / 2; if(A[mid] < target){ start = mid + 1; }else if(A[mid] > target){ end = mid - 1; }else{ if(result[0] == -1){ result[0] = mid; }else{ result[0] = Math.min(result[0], mid); } //找最左边界 end = mid - 1; } } start = result[0] == -1 ? 0 : result[0]; end = A.length - 1; while(start <= end){ int mid = start + (end -start) / 2; if(A[mid] < target){ start = mid + 1; }else if(A[mid] > target){ end = mid - 1; }else{ result[1] = Math.max(result[1], mid); //找最右边界 start = mid + 1; } } return result; } }