本文共 3896 字，大约阅读时间需要 12 分钟。

特点

1. 底层必须依赖数组

实现

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;}

1. 循环退出条件注意是 low<=high，而不是 low
2. mid 的取值
   实际上，mid=(low+high)/2 这种写法是有问题的。因为如果 low 和 high 比较大的话，两者之和就有可能会溢出。可将 mid 的计算方式写成 low+(high-low)/2，更进一步low+((high-low)>>1)（计算机处理位运算要快得多）
3. low 和 high 的更新low=mid+1，high=mid-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);  }}

二分查找应用场景的局限性

1. 底层必须依赖数组

二分查找算法需要按照下标随机访问元素

2. 数组必须有序

二分查找只能用在插入、删除操作不频繁（每次插入删除就得保证数据仍然有序）一次排序多次查找的场景中。针对动态变化的数据集合，二分查找将不再适用。

3. 数据量太小不适合

一次折一般嘛，多了才有优势嘛！

4. 数据量太大也不适合

因为底层是数组，哪有那么大的连续空间？！

思考题

1. 假设我们有 1000 万个整数数据，每个数据占 8 个字节，如何设计数据结构和算法，快速判断某个整数是否出现在这 1000 万数据中？ 我们希望这个功能不要占用太多的内存空间，最多不要超过 100MB，你会怎么做呢？
   这个问题并不难。我们的内存限制是 100MB，每个数据大小是 8 字节，最简单的办法就是将数据存储在数组中，内存占用差不多是 80MB，符合内存的限制。借助今天讲的内容，我们可以先对这 1000 万数据从小到大排序，然后再利用二分查找算法，就可以快速地查找想要的数据了。
2. 如何编程实现“求一个数的平方根”？要求精确到小数点后 6 位。
3. 如果数据使用链表存储，二分查找的时间复杂就会变得很高，那查找的时间复杂度究竟是多少呢？如果你自己推导一下，你就会深刻地认识到，为何我们会选择用数组而不是链表来实现二分查找了。
   假设链表长度为n，二分查找每次都要找到中间点(计算中忽略奇偶数差异):
   第一次查找中间点，需要移动指针n/2次；
   第二次，需要移动指针n/4次；
   第三次需要移动指针n/8次；
   …
   以此类推，一直到1次为值
   总共指针移动次数(查找次数) = n/2 + n/4 + n/8 + …+ 1，这显然是个等比数列，根据等比数列求和公式：Sum = n - 1.
   最后算法时间复杂度是：O(n-1)，忽略常数，记为O(n)，时间复杂度和顺序查找时间复杂度相同
   但是稍微思考下，在二分查找的时候，由于要进行多余的运算，严格来说，会比顺序查找时间慢

凡是用二分查找能解决的，绝大部分我们更倾向于用散列表或者二叉查找树。求“值等于给定值”的二分查找确实不怎么会被用到，二分查找更适合用在“近似”查找问题，在这类问题上，二分查找的优势更加明显。比如今天讲的这几种变体问题，用其他数据结构，比如散列表、二叉树，就比较难实现了。

二分法查找变形问题

变体一：查找第一个值等于给定值的元素

public int bsearch(int[] a, int n, int value) {
     int low = 0;  int high = n - 1;  while (low <= high) {
       int mid =  low + ((high - low) >> 1);    if (a[mid] > value) {
         high = mid - 1;    } else if (a[mid] < value) {
         low = mid + 1;    } else {
         if ((mid == 0) || (a[mid - 1] != value)) return mid;      else high = mid - 1;    }  }  return -1;}

变体二：查找最后一个值等于给定值的元素

public int bsearch(int[] a, int n, int value) {
     int low = 0;  int high = n - 1;  while (low <= high) {
       int mid =  low + ((high - low) >> 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 bsearch(int[] a, int n, int value) {
     int low = 0;  int high = n - 1;  while (low <= high) {
       int mid =  low + ((high - low) >> 1);    if (a[mid] >= value) {
         if ((mid == 0) || (a[mid - 1] < value)) return mid;      else high = mid - 1;    } else {
         low = mid + 1;    }  }  return -1;}

变体四：查找最后一个小于等于给定值的元素

public int bsearch7(int[] a, int n, int value) {
     int low = 0;  int high = n - 1;  while (low <= high) {
       int mid =  low + ((high - low) >> 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;}

思考：假设我们有 12 万条这样的 IP 区间与归属地的对应关系，如何快速定位出一个 IP 地址的归属地呢？

[202.102.133.0, 202.102.133.255]  山东东营市 [202.102.135.0, 202.102.136.255]  山东烟台 [202.102.156.34, 202.102.157.255] 山东青岛 [202.102.48.0, 202.102.48.255] 江苏宿迁 [202.102.49.15, 202.102.51.251] 江苏泰州 [202.102.56.0, 202.102.56.255] 江苏连云港

转载地址：http://xhsv.baihongyu.com/