时间复杂度O(logn)

三个易出错的地方
退出循环条件
mid取值
low和high更新

非递归

public int bsearch(int[] a, int n, int value) {
  int low = 0;
  int high = n - 1;

  while (low <= high) {
    int mid =low + (high-low)/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 static int searchFirstPosition(int[] arr,int key){
        int lo = 0;
        int hi = arr.length - 1;
        while (lo <= hi){
            int mid = lo + ((hi - lo) >> 1);
            if (key > arr[mid]){
                lo = mid + 1;
            } else if (key < arr[mid]){
                hi = mid - 1;
            } else {
                if (mid == 0 || arr[mid - 1] != key){
                    return mid;
                } else {
                    hi = mid - 1;
                }
            }
        }
        return -1;
    }

查找最后一个值等于给定值得元素

    //查找最后一个值等于给定值得元素
    public static int searchLastPostion(int[] arr,int key){
        int lo = 0;
        int hi = arr.length - 1;
        while (lo <= hi){
            int mid = lo + ((hi - lo) >> 1);
            if (key > arr[mid]){
                lo = mid + 1;
            } else if (key < arr[mid]){
                hi = mid - 1;
            } else {
                if (mid == arr.length - 1 || arr[mid + 1] != key){
                    return mid;
                } else {
                    lo = mid + 1;
                }
            }
        }
        return -1;
    }

查找第一个大于给定值的元素

    //查找第一个大于给定值的元素3,4,6,7,10中查找大于等于5的元素，那就是6
    public static int searchFirstBigOrEqualsPosition(int[] arr,int key){
        int lo = 0;
        int hi = arr.length - 1;
        while (lo <= hi){
            int mid = lo + ((hi - lo) >> 1);
            if (key <= arr[mid]){
                if (mid == 0 || arr[mid - 1] < key){
                    return mid;
                } else {
                    hi = mid - 1;
                }
            } else {
                lo = mid + 1;
            }
        }
        return -1;
    }

查找最后一个小于等于给定值的元素

    //查找最后一个小于等于给定值的元素
    public static int searchLastSmallOrEqualsPosition(int[] arr,int key){
        int lo = 0;
        int hi = arr.length - 1;
        while (lo <= hi){
            int mid = lo + ((hi - lo) >> 1);
            if (key >= arr[mid]){
                if (mid == arr.length - 1 || arr[mid + 1] > key){
                    return mid;
                } else {
                    lo = mid + 1;
                }
            } else {
                hi = mid - 1;
            }
        }
        return -1;
    }

可以用二分查找的解决的问题基本都使用散列表或者二叉树解决，即便是二分查找在内存上更节省，那二分查找在实际使用中要用在哪里？答案就是近似值查找，这种二分查找的变种。因为这种近似值查找散列表和二叉树实现起来都比较难