从一个例子开始，
两个人进行猜数游戏，其中一个人写下一个数字，另外一个人猜，每猜一个数，给这个人说大了还是小了，继续猜，比如猜一个100以内的数，写下的数是64，最多猜7次就可以猜到这个数，这里就使用了二分思想。
二分思想是一个应用很广泛的思想，比如对于一个有序数组，它能将查找效率从O(n)优化到O(logn)，因为每次可以将范围缩小为上一次的一半。这是在数组中的应用场景，我们以这个为基础来分析一下二分查找的时间复杂度
对于一个有 n 个元素的有序数组中，每次查找后缩小数据范围为上一次的二分之一，所以有
n/2 , n/4 , n/8, … , n/(2^k)
当 n/(2^k) = 1 时，得到最终结果，则 k = logn，记作二分查找的时间复杂度 O(logn)，是一个非常高效的算法；举个例子，如果我们在一个40亿的数据中查找某个数，也只需要32次，相对于顺序查找效率提升了太多，可见其威力。
总结一下，二分查找是针对一个有序集合，每次通过将要查找的数据范围缩小为上一次的一半，直到找到目标值，或者区间缩小为0。二分查找正是在有序数组上应用了二分思想。
二分思想其实是一种解决问题的思想，为了加速查找效率而生，所谓的二分并不代表一定是二，也可以是三，可以是N，只是一种表述，表达的意思是以最快的速率将搜索数据的范围缩小。
1 public class BinarySearch {
2 // 二分查找实现
3 public static int search(int[] arr, int target) {
4 int low = 0, high = arr.length - 1;
5
6 // 这里的中止条件是 low <= high, 因为 high = arr.length - 1
7 while (low <= high) {
8 // 使用 low + (high - low) / 2, 而不使用 (high + low) / 2, 是因为 high + low 可能造成整型溢出
9 // int mid = low + (high - low) / 2; // 这种方式是可以的，不如位运算效率高
10 int mid = low + ((high - low) >> 1); // 这种方式是最优的，效率最高
11
12 if (arr[mid] == target) {
13 return mid; 14 } else if (arr[mid] > target) { 15 high = mid - 1; 16 } else { 17 low = mid + 1; 18 } 19 } 20 return -1; 21 } 22 23 // 利用递归实现二分查找 24 public static int searchRecursive(int[] arr, int target) { 25 return recurSearch(arr, target, 0, arr.length - 1); 26 } 27 private static int recurSearch(int[] arr, int target, int left, int right) { 28 // terminator 29 if (left > right) 30 return -1; 31 32 int mid = left + ((right - left) >> 1); 33 34 if (arr[mid] == target) { 35 return mid; 36 } else if (arr[mid] > target) { 37 return recurSearch(arr, target, left, mid - 1); 38 } else { 39 return recurSearch(arr, target, mid + 1, right); 40 } 41 } 42 }
以上是一个常规的二分查找实现，这个数组中没有重复元素，查找给定值的元素，但是还有更难的：
- 查找第一个值等于给定值的元素位置
- 查找最后一个值等于给定值的元素位置
- 查找第一个大于等于给定值的元素位置
- 查找最后一个小于等于给定值的元素位置
这几个问题的代码都相对难写，代码实现如下：
1 class BinarySearchExt {
2 // 查找第一个值等于给定值的元素位置
3 public static int searchFirst(int[] arr, int target) {
4 int left = 0, high = arr.length - 1;
5
6 while (left <= right) {
7 int mid = left + (right - left) / 2;
8 if (arr[mid] > target) { 9 right = mid - 1; 10 } else if (arr[mid] < target) { 11 left = mid + 1; 12 } else { 13 if (mid == 0 || arr[mid - 1] != target) return mid; 14 else high = mid - 1; 15 } 16 } 17 18 return -1; 19 } 20 21 // 查找最后一个值等于给定值的元素位置 22 public static int searchLast(int[] arr, int target) { 23 int left = 0, high = arr.length - 1; 24 while (left <= right) { 25 int mid = left + (right - left) / 2; 26 if (arr[mid] > target) { 27 right = mid - 1; 28 } else if (arr[mid] < target) { 29 left = mid + 1; 30 } else { 31 if ((mid == arr.length - 1) || (arr[mid + 1] != target)) return mid; 32 else left = mid + 1; 33 } 34 } 35 return -1; 36 } 37 38 // 查找第一个大于等于给定值的元素位置 39 public static int searchGte(int[] arr, int target) { 40 int left = 0, right = arr.length - 1; 41 while (left <= right) { 42 int mid = left + ((right - left) >> 1); 43 if (arr[mid] >= target) { 44 if ((mid == 0) || (arr[mid - 1] < target)) return mid; 45 else right = mid - 1; 46 } else { 47 left = mid + 1; 48 } 49 } 50 return -1; 51 } 52 53 // 查找最后一个小于等于给定值的元素位置 54 public static int searchLte(int[] arr, int target) { 55 int left = 0, right = arr.length - 1; 56 while (left <= right) { 57 int mid = left + ((right - left) >> 1); 58 if (arr[mid] <= target) { 59 if ((mid == arr.length - 1) || (arr[mid + 1] > target)) return mid; 60 else left = mid + 1; 61 } else { 62 right = mid - 1; 63 } 64 } 65 return -1; 66 } 67 }
做个总结，分析一下二分查找的应用场景：
- 二分查找依赖于顺序表结构，如数组；在链表上直接运用二分查找效率低
- 二分查找需要数据是有序的，乱序的数据集合中无法应用，因为没有办法二分；所以对于相对静态的数据，排序后应用二分查找的效率还是很不错的；而对于动态变化的数据集合，维护成本会很高
- 数据量太小，发挥不出二分查找的威力；但是如果比较操作比较耗时，还是推荐使用二分查找
- 数据量太大，内存放不下
一个思考题：如何在1000万整数中快速查找某个整数呢？要求内存限制是100M，可以使用二分查找，先对1000万整数分配一个数组，然后进行排序，然后再使用二分查找。其他的方法，可能无法满足内存限制的问题，比如散列表、跳表、AVL树等。
另外一个思考题：如何快速定位一个IP的归属地？假设有10万+的IP地址段和归属地的映射关系，我们先对IP地址段的起始地址转成整数后排序，利用二分查找“在有序数组中，查找最后一个小于等于给定值的元素位置“，这样就可以找到一个ip段，然后取出来判断是不是在这个段里，不在的话，返回未找到；否则返回对应的归属地。
延伸之链表上的二分思想应用
上面，我们分析说在链表上应用二分查找的效率很低，那么为什么呢？分析一下
假设有n个元素的有序链表，现在用二分查找搜索数据，第一次移动指针次数 n/2，第二次移动 n/4，一直到 1，所以总的移动次数相加就是 n-1 次 可见时间复杂度是 O(n), 这个和顺序查找链表的时间复杂度 O(n) 是同级别的，其实二分查找比顺序查找的效率更低，因为它做了更多次无谓的指针移动
我们知道了二分思想直接应用到链表上是不可行的，有没有其他的办法，其实有，就是为有序链表增加多级索引，在搜索的时候根据索引应用二分思想。
二分查找常见的算法题目
搜索插入位置，这是一道二分查找的直接应用
实现如下
1 class Solution {
2 public int searchInsert(int[] nums, int target) {
3 int left = 0, right = nums.length - 1;
4
5 int pos = -1;
6 while (left <= right) {
7 int mid = left + (right - left) / 2; 8 if (nums[mid] == target) { 9 pos = mid; 10 break; 11 } else if (nums[mid] > target) { 12 right = mid - 1; 13 } else { 14 left = mid + 1; 15 } 16 } 17 return pos == -1 ? left : pos; 18 } 19 }
这个题目也是二分查找的一个拓展题目，代码实现如下
1 class Solution {
2 public int search(int[] nums, int target) {
3 if (nums.length == 1) return nums[0] == target ? 0 : -1;
4 int low = 0, high = nums.length - 1;
5
6 while (low <= high) {
7 int mid = low + (high - low) / 2; 8 9 if (nums[mid] == target) return mid; 10 11 // 这里是关键 12 // nums[low] <= target && target < nums[mid] 表示 low mid 是有序的，且target在它们中间，需要将high向前移动 13 // nums[low] > nums[mid] && target > nums[high] 表示 low ~ mid 是无序的，而且 target 比 high 位置的元素还要大，因为 mid ~ high 是有序的，所以必然在 low ~ mid 中间，移动high 14 // nums[low] > nums[mid] && target < nums[mid] 表示 low ~ mid 是无序的, 而且 target 比mid位置处的值还要小，因为 mid ~ high 是有序的，所以必然在 low ~ mid 中间，移动high 15 // 否则，就是移动low 16 if ((nums[low] <= target && target < nums[mid]) || 17 (nums[low] > nums[mid] && target > nums[high]) || 18 (nums[low] > nums[mid] && target < nums[mid])) { 19 // 这里是 20 high = mid - 1; 21 } else { 22 low = mid + 1; 23 } 24 } 25 26 return low == high && nums[low] == target ? low : -1; 27 } 28 }
Pow(x,n)
x的平方根，如果是精确到小数后6位呢？
1 class Solution {
2 // 关键是边界
3 public int findMin(int[] nums) {
4 int low = 0, high = nums.length - 1;
5 int lastElement = nums[high];
6 while (low < high) {
7 int mid = low + ((high - low) >> 1); 8 // 比最后一个元素小，说明转折点必定在mid的左边, 搜索左边 9 if (nums[mid] < lastElement) high = mid; 10 // 否则在右边 11 else low = mid + 1; 12 } 13 return nums[low]; 14 } 15 }