二分查找

描述：给定一个排序的整数数组（升序）和一个要查找的整数target，用O(logn)的时间查找到target第一次出现的下标（从0开始），如果target不存在于数组中，返回-1。

样例：在数组 [1, 2, 3, 3, 4, 5, 10] 中二分查找3，返回2。以及测试用例：a={1,4,4,5,7,7,8,9,9,10}

题很简单但是由于这个道题需要返回target第一次出现的下标，一开始将key = 0，然后如果有和target相等的值就将下标赋值给key，最后来判断key是否为0，如果是则返回1，如果不是则返回下标。

很明显当数组中第一个值就是target时这个解法就有问题了。例如样例中寻找 target=1；

后来参考别人的代码，发现可以把找到的target值赋值给nums[0],同时将下标mid赋值给key，如果num[0]的值等于target时，就返回key， 否则返回0；

 public int binarySearch(int[] nums, int target) {
        // write your code here
        if (nums == null || nums.length == 0) {
           return -1;
       }
       int hight = nums.length-1;
       int low = 0;
       int mid = 0;
       int key = 0;
       while(low <= hight){
           mid = (low + hight)/2;   //之前粗心没有除2然后竟然也过   
           if(nums[mid] > target){
               hight = mid-1;
           }
           else if(nums[mid] < target){
               low = mid + 1;
           }
           else{
               nums[0] = nums[mid];
               key = mid;
               hight = mid -1;
           }
       }
       if(nums[0] == target)         
           return key;
    return -1;
    }

在计算数组的中间位置时，为什么更喜欢start+(end-start)/2而不是(start+end)/2？

 https://cloud.tencent.com/developer/ask/29546

有三个原因。

首先，start + (end - start) / 2不会溢出1。

int *start = ..., *end = ...;
int *mid = start + (end - start) / 2; // works as expected
int *mid = (start + end) / 2;         // type error, won't compile

其次，start + (end - start) / 2不会溢出start and end

int start = 0x7ffffffe, end = 0x7fffffff;
int mid = start + (end - start) / 2; // works as expected
int mid = (start + end) / 2;         // overflow... undefined

只要使用 end >= start...

unsigned start = 0xfffffffeu, end = 0xffffffffu;
unsigned mid = start + (end - start) / 2; // works as expected
unsigned mid = (start + end) / 2;         // mid = 0x7ffffffe

最后 start 原素

int start = -3, end = 0;
int mid = start + (end - start) / 2; // -2, closer to start
int mid = (start + end) / 2;         // -1, surprise!