二分法查找算法

   二分法查找具有驚人的查找速度，尤其是對於海量數據的時候，作用更加明顯，時間復雜度用大O表示法，即是（logn），這種（logn）時間復雜度是非常神奇的，比如 n 等於 2 的 32 次方，這個數很大了吧？大約是42億，也就是說，如果我們在 42 億個數據中用二分查找一個數據，最多需要比較 32 次。

  但是，二分查找是有局限性的：

（1）二分查找依賴的是順序表結構，簡單點說就是數組。

解釋：主要原因是二分查找算法需要按照下標隨機訪問元素。

（2）二分查找針對的是有序數據。

（3）數據量太小不適合二分查找。

（4）數據量太大也不適合二分查找。

解釋：二分查找的底層需要依賴數組這種數據結構，而數組為了支持隨機訪問的特性，要求內存空間連續，對內存的空間要求比較苛刻。比如，我們有1GB的數據，那就需要1GB內存空間。

接下來是二分算法的代碼了：

//二分法查找給定值 普通Java實現
public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;

  while (low <= high) {
    int mid = (low + high) / 2;
    if (a[mid] == value) {
      return mid;
    } else if (a[mid] < value) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }

  return -1;
}

// 二分查找的遞歸實現
public int bsearch(int[] a, int n, int val) {
  return bsearchInternally(a, 0, n - 1, val);
}

private int bsearchInternally(int[] a, int low, int high, int value) {
  if (low > high) return -1;

  int mid =  low + ((high - low) >> 1);
  if (a[mid] == value) {
    return mid;
  } else if (a[mid] < value) {
    return bsearchInternally(a, mid+1, high, value);
  } else {
    return bsearchInternally(a, low, mid-1, value);
  }
}

    //查找第一個值等於給定值的元素
    public int bsearch1(int[] a, int n, int value){
        int low = 0;
        int high = n - 1;
        
        while(low <= high){
            //這里用到的(右移)>>運算符  右移運算符簡單理解就是 除以2的移動次冪 下面這個就是 等同於(high-low)/2^1
            int mid = low + ((high-low) >> 1);
            if(a[mid] > value){
                //說明value 在前半部分 把排好序的數組 從中間一切兩半
                high = mid - 1;
            }else if(a[mid] < value){
                //說明value 在后半部分
                low = mid + 1;
            }else{
                //a[mid] == value
                //但是我們要查找的是第一個 等於改定值的元素 還需要確認一下a[mid] 是不是第一個
                if(mid == 0 || a[mid - 1] != value){
                    //當mid == 0 的時候，說明這是第一個元素，肯定是我們要找的
                    //當a[mid] 前面的元素不等於 value的時候，說明a[mid]肯定就是第一個等於給定值的元素
                    //因為該數組是有序的，這里就是默認從小到大排序
                    return mid;
                }else{
                    high = mid - 1;
                }
            }
        }
        //這個 -1 代表的就是沒有找到
        return -1;
    }
    
    //查找最后一個值等於給定元素
    public int bsearch2(int[] a, int n, int value){
        int low = 0;
        int high = n - 1;
        
        while(low <= high){
            int mid = low + ((low+high) >> 1);
            if(a[mid] > value){
                high = mid - 1;
            }else if(a[mid] < value){
                low = mid + 1;
            }else{
                if(mid == n-1 || a[mid+1] != value){
                    //同理
                    return mid;
                }else{
                    low = mid + 1;
                }
            }
        }
        return -1;
    }
    
    //查找第一個大於等於給定值的元素
    public int bsearch3(int[] a, int n, int value){
        int low = 0;
        int high = n - 1;
        
        while(low <= high){
            int mid = low + ((low+high) >> 1);
            if(a[mid] >= value){
                if(mid == 0 || a[mid-1] < value){
                    //a[mid] 是第一個數，但是a[mid]大於等於value的數，所以肯定就是它了
                    //a[mid - 1] 是小於 value 的數，它的前一個數是小於value的，肯定也是它了
                    return mid;
                }else{
                    high = mid - 1;
                }
            }else{
                low = mid + 1;
            }
        }
        return -1;
    }
    
    //查找最后一個小於等於給定值得元素
    public int bsearch4(int[] a, int n, int value){
        int low = 0;
        int high = n -1;
        
        while(low <= high){
            int mid = low + ((low+high) >> 1);
            if(a[mid] > value){
                high = mid - 1;
            }else{
                if(mid == n-1 || a[mid+1] > value){
                    //同理
                    return mid;
                }else{
                    low = mid + 1;
                }
            }
        }    
        return -1;
    }