一.二分查找基础

1、二分查找介绍

二分查找(Binary search)也称折半查找，是一种效率较高的查找方法，时间复杂度。当对查数题目有时间复杂度要求是，首先就要考虑到二分查找。二分查找的思想很简单，属于分治策略的变种情况。但是，二分查找要求线性表中的记录必须是有序的集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0，所以必须采用顺序存储。

2、二分查找演示

下面是二分查找与顺序查找的演示图对比：

可以看出二分查找在查找数字 3 时只需3次，而顺序查找在查找3时需要3次。

3、二分查找原理

二分查找算法的原理如下：

假设在[begin，end)范围内搜索某个元素 v，mid == (begin + end)/ 2，end指的是数组的长度。

比较v与arr[mid]，有以下三种情况：

1)若 v < arr[mid]，则high = mid - 1；继续查找在左半区间进行；

2)若 v > arr[mid]，则low = mid + 1；继续查找在右半区间进行；

3)若 v = arr[mid]，则查找成功，返回 mid 值；

总结：如果大家有学习过二叉树知识，其实二分查找原理就是来自于二叉查找树(即：二叉平衡树)，所以查找的最大次数就是二叉树深度。

4、二分查找性能

二分查找最好时间复杂度是：最好情况下只需要进行1次比较就能找到目标元素；

二分查找最坏时间复杂度是：最坏情况就是查找不到目标元素，所需的时间复杂度可借助该序列的二叉树(二分查找判定树)形式进行分析：

序列[4,13,14,15,34,40,45,47,48,49,55]可以构建成下图所示的二叉树，以及查找对应的值14的过程图如下：

具有n个结点的二分查找树的深度为

，因此，查找成功时，所进行的关键码比较次数至多为

。而查找失败时和目标元素进行比较的次数最多也不超过树的深度

，因此最坏时间复杂度时

。二分查找平均时间复杂度是

。

5.代码模板

 1 int binarySearch(int[] nums, int target) {
 2     int left = 0; 
 3     int right = nums.length - 1; // 注意
 4     while(left <= right) {
 5         int mid = left + (right - left) / 2;
 6         if(nums[mid] == target)
 7             //这里根据具体情况设定
 8         else if (nums[mid] < target)
 9             left = mid + 1; // 注意
10         else if (nums[mid] > target)
11             right = mid - 1; // 注意
12     }
13 //其他特殊情况处理，主要是左右边界情况
14 }

二.常见题型

题型一：寻找一个数(基本的二分搜索)

比如我们给定数组如下动态图中，我们需要查找等于673的元素，如果存在，返回其索引，否则返回 -1。[left, right]

 1 int binarySearch(int[] nums, int target) {
 2     int left = 0; 
 3     int right = nums.length - 1; // 注意
 4     while(left <= right) {
 5         int mid = left + (right - left) / 2;
 6         if(nums[mid] == target)
 7             return mid; 
 8         else if (nums[mid] < target)
 9             left = mid + 1; // 注意
10         else if (nums[mid] > target)
11             right = mid - 1; // 注意
12     }
13     return -1;
14 }

题型二：寻找左侧边界的二分搜索

比如我们给定数组1,2,3,4,4,4,5,6,7,7,8,9，我们需要查找第一个等于4的元素，「搜索区间」是[left, right]

 1 int left_bound(int[] nums, int target) {
 2     int left = 0, right = nums.length - 1;
 3     while (left <= right) {
 4         int mid = left + (right - left) / 2;
 5         if (nums[mid] < target) {
 6             left = mid + 1;
 7         } else if (nums[mid] > target) {
 8             right = mid - 1;
 9         } else if (nums[mid] == target) {
10             // 别返回，锁定左侧边界
11             right = mid - 1;
12         }
13     }
14     // 最后要检查 left 越界的情况
15     if (left >= nums.length || nums[left] != target)
16         return -1;
17     return left;
18 }

题型三：寻找右侧边界的二分查找

比如我们给定数组1,2,3,4,4,4,5,6,7,7,8,9，我们需要查找最后一个等于4的元素，「搜索区间」是[left, right]

 1 int right_bound(int[] nums, int target) {
 2     int left = 0, right = nums.length - 1;
 3     while (left <= right) {
 4         int mid = left + (right - left) / 2;
 5         if (nums[mid] < target) {
 6             left = mid + 1;
 7         } else if (nums[mid] > target) {
 8             right = mid - 1;
 9         } else if (nums[mid] == target) {
10             // 别返回，锁定右侧边界
11             left = mid + 1;
12         }
13     }
14     // 最后要检查 right 越界的情况
15     if (right < 0 || nums[right] != target)
16         return -1;
17     return right;
18 }

题型四：查找第一个大于给定值的元素

比如我们给定数组1,2,3,4,4,4,5,6,7,7,8,9,15,26,34,45，我们随便输入一个值，这个值可以是数组里面的值，也不可不在数组里面，查找出第一个比给定值大的元素。

 1    /**
 2      * 查找第一个大于给定值的元素
 3      *
 4      * @param nums   数组
 5      * @param value  给定的值
 6      * @return
 7      */
 8     private static int sercFirstOverVlaue(int[] nums, int value) {
 9         int low = 0;
10         int high = nums.length - 1;
11         while (low <= high) {
12             int mid = low + ((high - low) >> 1);
13             if (nums[mid] > value) {
14                 // 判断当前是第一个元素或者前一个元素小于等于给定值，则返回下标，如果前一个元素大于给定的值，则继续往前查找。
15                 if ((mid == 0) || nums[mid - 1] <= value) return mid;
16                 else high = mid - 1;
17             } else {
18                 low = mid + 1;
19             }
20         }
21         return -1;
22     }

三.扩展题型(来自leetcode)

题目一：240. 搜索二维矩阵 II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。

每列的元素从上到下升序排列。

示例 1：

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5

输出：true

示例 2：

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20

输出：false

思路：

这道题的关键在于得找到特殊位置的起始点，从该起始点，可以分治地去查找待查找地点。

主对角线上左上角和右下角不符合条件，因为

左上角的点，其周围的点都比它大，没法找到合适的查找路径

右下角的点，其周围的点都比它小，没法找到合适的查找路径

次对角线上左下角和右上角的点更合适，因为

左下角的点：往上比它小，往右比它大

右上角的点：往左比它小，往下比它大

因此，选择左下角或右上角的点都合适。

 1 public boolean searchMatrix(int[][] matrix, int target) {
 2     int n = matrix.length
 3     int m = matrix[0].length;
 4     int i = 0, j = m - 1; // 从右上角开始走
 5     while(i < n && j >= 0) { // 最多会走到左下角去
 6         int a = matrix[i][j];
 7         if (a == target) return true;
 8         if (a < target) i++; // 排除掉当前这一行, 往下走
 9         else j--; // 排除掉当前这一列, 往左走
10     }
11     return false;
12 }

题目二：4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]

输出：2.00000

解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]

输出：2.50000

解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

解法一：直接找中位数

我们不需要将两个数组真的合并，我们只需要找到中位数在哪里就可以了。

 1 public double findMedianSortedArrays(int[] A, int[] B) {
 2     int m = A.length;
 3     int n = B.length;
 4     int len = m + n;
 5     int left = -1, right = -1;
 6     int aStart = 0, bStart = 0;
 7     for (int i = 0; i <= len / 2; i++) {
 8         left = right;
 9         if (aStart < m && (bStart >= n || A[aStart] < B[bStart])) {
10             right = A[aStart++];
11         } else {
12             right = B[bStart++];
13         }
14     }
15     if ((len & 1) == 0)
16         return (left + right) / 2.0;
17     else
18         return right;
19 }

空间复杂度：我们申请了常数个变量，也就是m，n，len，left，right，aStart，bStart 以及 i。时间复杂度：遍历 len/2+1 次，len=m+n，所以时间复杂度依旧是 O(m+n)O(m+n)。

总共 8 个变量，所以空间复杂度是 O(1)O(1)

解法二：二分查找

我们一次遍历就相当于去掉不可能是中位数的一个值，也就是一个一个排除。求两个有序数组的中位数，可以变换为，求第k个数。由于两个数组有序，我们每次只要从两个数组中，分别从左取k/2个数，然后想象尝试将这2组k/2个数合并。若第1组的最后一个数，小于第2组的最后一个数，则第1组不可能作为第k个数，那么可以将第1组的k/2个数全部排除。时间复杂度 O ( l o g ( m + n ) ) ，空间复杂度 O ( 1 ) 。

 1 class Solution {
 2     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
 3         int n = nums1.length, m = nums2.length;
 4         int left = (n + m + 1)>>1;
 5         int right = (n + m + 2)>>1;
 6         int median1 = getKth(nums1, nums2, left);
 7         int median2 = getKth(nums1, nums2, right);
 8         return (median1 + median2) / 2.0;
 9     }
10 
11     private int getKth(int[] nums1, int[] nums2, int k) {
12         int n = nums1.length, m = nums2.length;
13         int i = 0, j = 0;
14         while (i < n && j < m && k > 1) {
15             int ie = Math.min(i + k>>1 - 1, n - 1);
16             int je = Math.min(j + k>>1 - 1, m - 1);
17             if (nums1[ie] <= nums2[je]) {
18                 k -= (ie - i + 1); // 更新k
19                 i = ie + 1; // 更新i, 注意不要先更新i, 再更新 k
20             } else {
21                 k -= (je - j + 1);
22                 j = je + 1;
23             }
24         }
25         if (i >= n) return nums2[j + k - 1];
26         if (j >= m) return nums1[i + k - 1];
27         return Math.min(nums1[i], nums2[j]);
28     }
29 }

题目三：33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标从 0 开始计数)。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0

输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3

输出：-1

示例 3：

输入：nums = [1], target = 0

输出：-1

解题思路：二分查找

nums[0] <= nums[mid](0 - mid不包含旋转)且nums[0] <= target <= nums[mid] 时 high 向前规约；

nums[mid] < nums[0](0 - mid包含旋转)，target <= nums[mid] < nums[0] 时向前规约(target 在旋转位置到 mid 之间)

nums[mid] < nums[0]，nums[mid] < nums[0] <= target 时向前规约(target 在 0 到旋转位置之间)

其他情况向后规约

也就是说nums[mid] < nums[0]，nums[0] > target，target > nums[mid] 三项均为真或者只有一项为真时向后规约。

 1 public int search(int[] nums, int target) {
 2     if(nums.length==0){
 3         return -1;
 4     }
 5     if(nums.length==1){
 6         return nums[0]==target? 0:-1;
 7     }
 8     int n=nums.length;
 9     int i=0;
10     int j=n-1;
11     while(i<=j){
12         int mid=i+(j-i)/2;
13         if(nums[mid]==target){
14             return mid;
15         // 如果mid在左边, 注意nums[mid]可能等于nums[0]
16         }else if(nums[0]<=nums[mid]){
17             // target也在左边
18             if(nums[0]<=target && target<nums[mid]){
19                 j=mid-1;
20             }else{
21                 i=mid+1;
22             }
23         // 如果mid在右边
24         }else if(nums[mid]<nums[0]){
25             // target也在右边
26             if(nums[mid]<target && target<=nums[n-1]){
27                 i=mid+1;
28             }else{
29                 j=mid-1;
30             }
31         }
32     }
33     return -1;
34 }

四.总结

我想大家对二分查找算法题目会遇到很多的写法，比如While判断逻辑中存在左闭右闭区间 [left,right]或左闭右开区间 [left,right)场景。不管是那种情况，都需要考虑边界条件，大家只需要考虑某一种判断逻辑即可，不需要全部记忆，增加负担。

1、二分查找算法具有三个作用：搜索目标值，搜索目标值的左边界(序列中最大的小于目标值的元素)，搜索目标值的右边界(序列中最小的大于目标值的元素)。

2、while循环的判断条件和搜索区间右边界right的赋值方式与right的初始化取值有关。right初始化为序列长度，则判断条件为left<right，赋值方式为right=mid；right初始化为序列长度-1，则判断条件为left<=right，赋值方式为right=mid-1。

3、二分查找三个作用的实现取决于while循环中对“序列中位数==目标值”这一情况的处理：

 1 1、搜索目标值
 2 if(nums[mid]==target)
 3     return mid;
 4 
 5 2、搜索目标值的左边界
 6 if(nums[mid]==target)
 7     right=mid;  //最后结果左边界=right-1
 8 或者
 9 if(nums[mid]==target)    
10     right=mid-1;//最后结果左边界=right
11 
12 3、搜索目标值的右边界
13 if(nums[mid]==target)
14     left=mid+1;

我这里只给了大家<=的情况，大家如果不适应，可以留言给大家提供<的情况代码。

更多精彩关注wx公众号：