-（1）有一个升序排列的非负数组，要求利用o（logn）的时间复杂度找到数组中确定数字target的第一次出现的位置下标和最后一次出现的位置下标，如果不存在该target返回[-1,-1]
解决方案：本题是考察二分查找算法，通过两次二分查找算法找到target的起始下标和终止下标，放在一个数组中返回
public int[] findFirstAndLastIndex(int[] nums,int target){
int[] res = new int[]{-1,-1};
if(nums==null || nums.length<=1||target<0)
return res;
res[0]=findFirst(nums,target);
res[1]=findLast(nums,target);
return res;
}
public int findFirst(int[] nums,int target){
int idx=-1;
int start=0,end=nums.length-1,mid=0;
while(start<=end){
mid=start+(end-start)/2;
if(nums[mid]>=target)
end=mid-1;
else
start=mid+1;
if(nums[mid]==target)
idx=mid;
}
return idx;
}
public int findLast(int[] nums,int target){
int idx=-1;
int start=0,end=nums.length-1,mid=0;
while(start<=end){
mid=start+(end-start)/2;
if(nums[mid]<=target)
start=mid+1;
else
end=mid-1;
if(nums[mid]==target)
idx=mid;
}
return idx;
}
(2) 每一个app开发出来后，我们需要定期的对其进行更新（不管是升级还是修改bug），假设app当前已有n个版本，如果某一个版本出现错误，那么从这个版本开始后面的版本全部会出错，要求我们找出第一个出现错误的版本
解决方案：还是二分查找，当我们当前的mid对于的版本是错误版本（假设给定一个函数isError（viersion），true为错误版本，flase为正确版本），我们就往mid的左半部分找到初始错误版本，否则，就往mid右半部分找到初始错误版本
public int findFirstErrorVersion（int n）{
int start=1,end=n,mid=1;
while(start<end){
mid=start+(end-start)/2;//为什么不是mid=（start+end）/2
if(!isError（mid））
start=mid+1;
else
end=mid;
}
return start;
}
接下来，我解释一下上面的一个问题，为什么不能写成mid=（start+end）/2，因为，start，end均为整型数据，int型数据的最大值为2147483647，假如这里n=Integer.MAX_VALUE ,start=Integer.MAX_VALUE-1，end=Integer.MAX_VALUE，那么此时，（start+end）必须超过整型数据的返回，自然会出现问题，所以，一般情况下，最好还是写成start+（end-start）/2形式，何乐而不为呢？
补加：
Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead.
For example, given the array [2,3,1,2,4,3] and s = 7,
the subarray [4,3] has the minimal length under the problem constraint.
private int solveNLogN(int s, int[] nums) { int[] sums = new int[nums.length + 1]; for (int i = 1; i < sums.length; i++) sums[i] = sums[i - 1] + nums[i - 1]; int minLen = Integer.MAX_VALUE; for (int i = 0; i < sums.length; i++) { int end = binarySearch(i + 1, sums.length - 1, sums[i] + s, sums); if (end == sums.length) break; if (end - i < minLen) minLen = end - i; } return minLen == Integer.MAX_VALUE ? 0 : minLen; } private int binarySearch(int lo, int hi, int key, int[] sums) { while (lo <= hi) { int mid = (lo + hi) / 2; if (sums[mid] >= key){ hi = mid - 1; } else { lo = mid + 1; } } return lo; } }