# 第一期讲义-二分法

二分查找又称`折半搜索算法`。 狭义地来讲，二分查找是一种在有序数组查找某一特定元 素的搜索算法。这同时也是大多数人所知道的一种说法。实际上， 广义的二分查找是将问 题的规模缩小到原有的一半。类似的，三分法就是将问题规模缩小为原来的 1/3。

本文给大家带来的内容则是`狭义地二分查找`，如果想了解其他广义上的二分查找可以查看 我之前写的一篇博文 [从老鼠试毒问题来看二分法](https://lucifer.ren/blog/2019/12/11/laoshushidu/)

> 尽管二分查找的基本思想相对简单，但细节可以令人难以招架 ... — 高德纳

当乔恩·本特利将二分搜索问题布置给专业编程课的学生时，百分之 90 的学生在花费数小 时后还是无法给出正确的解答，主要因为这些错误程序在面对边界值的时候无法运行，或返 回错误结果。1988 年开展的一项研究显示，20 本教科书里只有 5 本正确实现了二分搜索 。不仅如此，本特利自己 1986 年出版的《编程珠玑》一书中的二分搜索算法存在整数溢出 的问题，二十多年来无人发现。Java 语言的库所实现的二分搜索算法中同样的溢出问题存 在了九年多才被修复。

可见二分查找并不简单， 本文就试图带你走近 ta，明白 ta 的底层逻辑，并提供模板帮助 大家写书 bug free 的二分查找代码。

大家可以看完讲义结合 [LeetCode Book 二分查找练习一下](https://leetcode-cn.com/leetbook/read/binary-search)

## 问题定义

给定一个由数字组成的有序数组 nums，并给你一个数字 target。问 nums 中是否存在 target。如果存在， 则返回其在 nums 中的索引。如果不存在，则返回 - 1。

这是二分查找中最简单的一种形式。当然二分查找也有很多的变形，这也是二分查找容易出 错，难以掌握的原因。

常见变体有：

* 如果存在多个满足条件的元素，返回最左边满足条件的索引。
* 如果存在多个满足条件的元素，返回最右边满足条件的索引。
* 数组不是整体有序的。 比如先升序再降序，或者先降序再升序。
* 将一维数组变成二维数组。
* 。。。

接下来，我们逐个进行查看。

## 前提

* 数组是有序的（如果无序，我们也可以考虑排序，不过要注意排序的复杂度）

## 术语

二分查找中使用的术语：

* target —— 要查找的值
* index —— 当前位置
* l 和 r —— 左右指针
* mid —— 左右指针的中点，用来确定我们应该向左查找还是向右查找的索引

## 常见题型

### 查找一个数

算法描述：

* 先从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；
* 如果目标元素大于中间元素，则在数组大于中间元素的那一半中查找，而且跟开始一样从 中间元素开始比较。
* 如果目标元素小于中间元素，则在数组小于中间元素的那一半中查找，而且跟开始一样从 中间元素开始比较。
* 如果在某一步骤数组为空，则代表找不到。

**复杂度分析**

* 平均时间复杂度： $O(logN)$
* 最坏时间复杂度： $O(logN)$
* 最优时间复杂度： $O(1)$
* 空间复杂度
  * 迭代: $O(1)$
  * 递归： $O(logN)$（无尾调用消除）

> 后面的复杂度也是类似的，不再赘述。

这种搜索算法每一次比较都使搜索范围缩小一半，是典型的二分查找。

这个是二分查找中最简答的一种类型了，我们先来搞定它。 我们来一个具体的例子， 这样 方便大家增加代入感。假设 nums 为 `[1,3,4,6,7,8,10,13,14]`， target 为 4·。

* 刚开始数组中间的元素为 7
* 7 > 4 ，由于 7 右边的数字都大于 7 ，因此不可能是答案。我们将范围缩写到了 7 的 左侧。
* 此时中间元素为 3
* 3 < 4，由于 3 左边的数字都小于 3 ，因此不可能是答案。我们将范围缩写到了 3 的右 侧。
* 此时中间元素为 4，正好是我们要找的，返回其索引 2 即可。

如何将上面的算法转换为容易理解的可执行代码呢？就算是这样一个简简单单，朴实无华的 二分查找， 不同的人写出来的差别也是很大的。 如果没有一个思维框架指导你，那么你在 不同的时间可能会写出差异很大的代码。这样的话，你犯错的几率会大大增加。

这里给大家介绍一个我经常使用的思维框架和代码模板。

#### 思维框架

\*\* 首先定义搜索区间为 \[left, right]，注意是左右都闭合，之后会用到这个点 \*\*

> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜 索区间。

* 由于定义的搜索区间为 \[left, right]，因此当 left <= right 的时候，搜索区间都不 为空，此时我们都需要继续搜索。 也就是说终止搜索条件应该为 left <= right。

> 举个例子容易明白一点。 比如对于区间 \[4,4]，其包含了一个元素 4，因此搜索区间不 为空，需要继续搜索（试想 4 恰好是我们要找的 target，如果不继续搜索， 会错过正 确答案）。而当搜索区间为 \[left, right) 的时候，同样对于 \[4,4]，这个时候搜索区 间却是空的，因为这样的一个区间不存在任何数字·。

* 循环体内，我们不断计算 mid ，并将 nums\[mid] 与 目标值比对。
  * 如果 nums\[mid] 等于目标值， 则提前返回 mid（只需要找到一个满足条件的即可）
  * 如果 nums\[mid] 小于目标值， 说明目标值在 mid 右侧，这个时候搜索区间可缩小为 \[mid + 1, right] （mid 以及 mid 左侧的数字被我们排除在外）
  * 如果 nums\[mid] 大于目标值， 说明目标值在 mid 左侧，这个时候搜索区间可缩小为 \[left, mid - 1] （mid 以及 mid 右侧的数字被我们排除在外）
* 循环结束都没有找到，则说明找不到，返回 -1 表示未找到。

#### 代码模板

**Java**

```java
public int binarySearch(int[] nums, int target) {
    // 左右都闭合的区间 [l, r]
    int left = 0;
    int right = nums.length - 1;

    while(left <= right) {
        int mid = left + (right - left) / 2;
        if(nums[mid] == target)
            return mid;
        if (nums[mid] < target)
			      // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        if (nums[mid] > target)
            // 搜索区间变为 [left, mid - 1]
            right = mid - 1;
    }
    return -1;
}
```

**Python**

```py
def binarySearch(nums, target):
    # 左右都闭合的区间 [l, r]
    l, r = 0, len(nums) - 1
    while l <= r:
        mid = (left + right) >> 1
        if nums[mid] == target: return mid
        # 搜索区间变为 [mid+1, right]
        if nums[mid] < target: l = mid + 1
        # 搜索区间变为 [left, mid - 1]
        if nums[mid] > target: r = mid - 1
    return -1

```

**JavaScript**

```js
function binarySearch(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor(left + (right - left) / 2);
    if (nums[mid] == target) return mid;
    if (nums[mid] < target)
      // 搜索区间变为 [mid+1, right]
      left = mid + 1;
    if (nums[mid] > target)
      // 搜索区间变为 [left, mid - 1]
      right = mid - 1;
  }
  return -1;
}
```

**C++**

```cpp
int binarySearch(vector<int>& nums, int target){
  if(nums.size() == 0)
    return -1;

  int left = 0, right = nums.size() - 1;
  while(left <= right){
    int mid = left + ((right - left) >> 1);
    if(nums[mid] == target){ return mid; }
    // 搜索区间变为 [mid+1, right]
    else if(nums[mid] < target)
	left = mid + 1;
    // 搜索区间变为 [left, mid - 1]
    else
	right = mid - 1;
  }
  return -1;
}
```

### 寻找最左边的满足条件的值

和`查找一个数`类似， 我们仍然套用`查找一个数`的思维框架和代码模板。

#### 思维框架

* 首先定义搜索区间为 \[left, right]，注意是左右都闭合，之后会用到这个点。
* 终止搜索条件为 left <= right。
* 循环体内，我们不断计算 mid ，并将 nums\[mid] 与 目标值比对。
  * 如果 nums\[mid] 等于目标值， 则收缩右边界，我们找到了一个备胎，继续看看左边还 有没有了（**注意这里不一样**）
  * 如果 nums\[mid] 小于目标值， 说明目标值在 mid 右侧，这个时候搜索区间可缩小为 \[mid + 1, right]
  * 如果 nums\[mid] 大于目标值， 说明目标值在 mid 左侧，这个时候搜索区间可缩小为 \[left, mid - 1]
* 由于不会提前返回，因此我们需要检查最终的 left，看 nums\[left]是否等于 target。
  * 如果不等于 target，或者 left 出了右边边界了，说明至死都没有找到一个备胎，则 返回 -1.
  * 否则返回 left 即可，备胎转正。

#### 代码模板

> 实际上 nums\[mid] > target 和 nums\[mid] == target 是可以合并的。我这里为了清晰 ，就没有合并，大家熟悉之后合并起来即可。

**Java**

```java
public int binarySearchLeft(int[] nums, int target) {
	// 搜索区间为 [left, right]
    int left = 0;
    int right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        }
        if (nums[mid] > target) {
            // 搜索区间变为 [left, mid-1]
            right = mid - 1;
        }
        if (nums[mid] == target) {
            // 收缩右边界
            right = mid - 1;
        }
    }
    // 检查是否越界
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}
```

**Python**

```py
def binarySearchLeft(nums, target):
    # 左右都闭合的区间 [l, r]
    l, r = 0, len(nums) - 1
    while l <= r:
        mid = (l + r) >> 1
        if nums[mid] == target:
            # 收缩右边界
            r = mid - 1;
        # 搜索区间变为 [mid+1, right]
        if nums[mid] < target: l = mid + 1
        # 搜索区间变为 [left, mid - 1]
        if nums[mid] > target: r = mid - 1
    if l >= len(nums) or nums[l] != target: return -1
    return l

```

**JavaScript**

```js
function binarySearchLeft(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor(left + (right - left) / 2);
    if (nums[mid] == target)
      // 收缩右边界
      right = mid - 1;
    if (nums[mid] < target)
      // 搜索区间变为 [mid+1, right]
      left = mid + 1;
    if (nums[mid] > target)
      // 搜索区间变为 [left, mid - 1]
      right = mid - 1;
  }
  // 检查是否越界
  if (left >= nums.length || nums[left] != target) return -1;
  return left;
}
```

**C++**

```cpp
int binarySearchLeft(vector<int>& nums, int target) {
	// 搜索区间为 [left, right]
    int left = 0, right = nums.size() - 1;
    while (left <= right) {
        int mid = left + ((right - left) >> 1);
        if (nums[mid] == target) {
            // 收缩右边界
            right = mid - 1;
        }
        if (nums[mid] < target) {
            // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        }
        if (nums[mid] > target) {
            // 搜索区间变为 [left, mid-1]
            right = mid - 1;
        }
    }
    // 检查是否越界
    if (left >= nums.size() || nums[left] != target)
        return -1;
    return left;
}
```

#### 例题解析

给你一个严格递增的数组 nums ，让你找到第一个满足 nums\[i] == i 的索引，如果没有这 样的索引，返回 -1。（你的算法需要有 logN 的复杂度）。

首先我们做一个小小的变换，将原数组 nums 转换为 A，其中 A\[i] = nums\[i] - i。这样 新的数组 A 就是一个不严格递增的数组。这样原问题转换为 在一个不严格递增的数组 A 中找第一个等于 0 的索引。接下来，我们就可以使用最左满足模板，找到最左满足 nums\[i] == i 的索引。

代码：

```py
class Solution:
    def solve(self, nums):
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = (l + r) // 2
            if nums[mid] >= mid:
                r = mid - 1
            else:
                l = mid + 1
        return l if l < len(nums) and nums[l] == l else -1
```

### 寻找最右边的满足条件的值

和`查找一个数`类似， 我们仍然套用`查找一个数`的思维框架和代码模板。

> 有没有感受到框架和模板的力量？

#### 思维框架

* 首先定义搜索区间为 \[left, right]，注意是左右都闭合，之后会用到这个点。

> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜 索区间。

* 由于我们定义的搜索区间为 \[left, right]，因此当 left <= right 的时候，搜索区间 都不为空。 也就是说我们的终止搜索条件为 left <= right。

> 举个例子容易明白一点。 比如对于区间 \[4,4]，其包含了一个元素 4，因此搜索区间不 为空。而当搜索区间为 \[left, right) 的时候，同样对于 \[4,4]，这个时候搜索区间却 是空的。

* 循环体内，我们不断计算 mid ，并将 nums\[mid] 与 目标值比对。
  * 如果 nums\[mid] 等于目标值， 则收缩左边界，我们找到了一个备胎，继续看看右边还 有没有了
  * 如果 nums\[mid] 小于目标值， 说明目标值在 mid 右侧，这个时候搜索区间可缩小为 \[mid + 1, right]
  * 如果 nums\[mid] 大于目标值， 说明目标值在 mid 左侧，这个时候搜索区间可缩小为 \[left, mid - 1]
* 由于不会提前返回，因此我们需要检查最终的 right，看 nums\[right]是否等于 target。
  * 如果不等于 target，或者 right 出了左边边界了，说明至死都没有找到一个备胎，则 返回 -1.
  * 否则返回 right 即可，备胎转正。

#### 代码模板

> 实际上 nums\[mid] < target 和 nums\[mid] == target 是可以合并的。我这里为了清晰 ，就没有合并，大家熟悉之后合并起来即可。

**Java**

```java
public int binarySearchRight(int[] nums, int target) {
	// 搜索区间为 [left, right]
    int left = 0
    int right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
			// 搜索区间变为 [mid+1, right]
            left = mid + 1;
        }
        if (nums[mid] > target) {
			// 搜索区间变为 [left, mid-1]
            right = mid - 1;
        }
        if (nums[mid] == target) {
            // 收缩左边界
            left = mid + 1;
        }
    }
    // 检查是否越界
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}
```

**Python**

```py
def binarySearchRight(nums, target):
    # 左右都闭合的区间 [l, r]
    l, r = 0, len(nums) - 1
    while l <= r:
        mid = (l + r) >> 1
        if nums[mid] == target:
            # 收缩左边界
            l = mid + 1;
        # 搜索区间变为 [mid+1, right]
        if nums[mid] < target: l = mid + 1
        # 搜索区间变为 [left, mid - 1]
        if nums[mid] > target: r = mid - 1
    if r < 0 or nums[r] != target: return -1
    return r
```

**JavaScript**

```js
function binarySearchRight(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor(left + (right - left) / 2);
    if (nums[mid] == target)
      // 收缩左边界
      left = mid + 1;
    if (nums[mid] < target)
      // 搜索区间变为 [mid+1, right]
      left = mid + 1;
    if (nums[mid] > target)
      // 搜索区间变为 [left, mid - 1]
      right = mid - 1;
  }
  // 检查是否越界
  if (right < 0 || nums[right] != target) return -1;
  return right;
}
```

**C++**

```cpp
int binarySearchRight(vector<int>& nums, int target) {
	// 搜索区间为 [left, right]
    int left = 0, right = nums.size() - 1;
    while (left <= right) {
        int mid = left + ((right - left) >> 1);
         if (nums[mid] == target) {
            // 收缩左边界
            left = mid + 1;
        }
        if (nums[mid] < target) {
			// 搜索区间变为 [mid+1, right]
            left = mid + 1;
        }
        if (nums[mid] > target) {
			// 搜索区间变为 [left, mid-1]
            right = mid - 1;
        }
    }
    // 检查是否越界
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}
```

### 寻找最左插入位置

上面我们讲了`寻找最左满足条件的值`。如果找不到，就返回 -1。那如果我想让你找不到 不是返回 -1，而是应该插入的位置，使得插入之后列表仍然有序呢？

比如一个数组 nums: \[1,3,4]，target 是 2。我们应该将其插入（注意不是真的插入）的 位置是索引 1 的位置，即 \[1,**2**,3,4]。因此`寻找最左插入位置`应该返回 1， 而`寻找最左满足条件` 应该返回-1。

另外如果有多个满足条件的值，我们返回最左侧的。 比如一个数组 nums: \[1,2,2,2,3,4]，target 是 2，我们应该插入的位置是 1。

#### 思维框架

如果你将**寻找最左插入位置**看成是**寻找最左满足**大于等于 x 的值，那就可以和前 面的知识产生联系，使得代码更加统一。唯一的区别点在于**前面是最左满足等于 x**，这 里是**最左满足大于等于 x**。

具体算法：

* 首先定义搜索区间为 \[left, right]，注意是左右都闭合，之后会用到这个点。

> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜 索区间。

* 由于我们定义的搜索区间为 \[left, right]，因此当 left <= right 的时候，搜索区间 都不为空。 也就是说我们的终止搜索条件为 left <= right。
* 当 A\[mid] >= x，说明找到一个备胎，我们令 r = mid - 1 将 mid 从搜索区间排除，继 续看看有没有更好的备胎。
* 当 A\[mid] < x，说明 mid 根本就不是答案，直接更新 l = mid + 1，从而将 mid 从搜 索区间排除。
* 最后搜索区间的 l 就是最好的备胎，备胎转正。

#### 代码模板

**Python**

```py
def bisect_left(A, x):
    # 内置 api
    bisect.bisect_left(A, x)
    # 手写
    l, r = 0, len(A) - 1
    while l <= r:
        mid = (l + r) // 2
        if A[mid] >= x: r = mid - 1
        else: l = mid + 1
    return l
```

**Java**

```java
import java.util.*;
public class BinarySearch {
    public int getPos(int[] A, int val) {
        int low=0,high=A.lenght-1;
        while (low <= high){
            int mid = (low + high)/2;
            if (A[mid] >= val) {
                high = mid-1;
            } else {
	    	low = mid+1;
	    } 
        }
        return low;
    }
}
```

**C++**

```cpp
public:
     int binarySearch(int* arr, int arrLen,int a) {
        int left = 0;
        int right = arrLen - 1;
        while(left<=right)
        {
            int mid = (left+right)/2;
            if(arr[mid]>=a)
                right = mid - 1;
            else
                left = mid + 1;
        }  
        return left;
    }
```

**JavaScript**

```js
function binarySearch(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor(left + (right - left) / 2);
    if (nums[mid] >= target) {
    	// 搜索区间变为 [left, mid-1]
    	right = mid - 1;
    }
    else {
    	// 搜索区间变为 [mid+1, right]
    	left = mid + 1;
    }
  }
  return left;
}
```

其他语言暂时空缺，欢迎 [PR](https://github.com/azl397985856/leetcode-cheat/issues/4)

### 寻找最右插入位置

#### 思维框架

如果你将**寻找最右插入位置**看成是**寻找最右满足**大于 x 的值，那就可以和前面的 知识产生联系，使得代码更加统一。唯一的区别点在于**前面是最左满足等于 x**，这里 是**最左满足大于 x**。

具体算法：

* 首先定义搜索区间为 \[left, right]，注意是左右都闭合，之后会用到这个点。

> 你可以定义别的搜索区间形式，不过后面的代码也相应要调整，感兴趣的可以试试别的搜 索区间。

* 由于我们定义的搜索区间为 \[left, right]，因此当 left <= right 的时候，搜索区间 都不为空。 也就是说我们的终止搜索条件为 left <= right。
* 当 A\[mid] > x，说明找到一个备胎，我们令 r = mid - 1 将 mid 从搜索区间排除，继 续看看有没有更好的备胎。
* 当 A\[mid] <= x，说明 mid 根本就不是答案，直接更新 l = mid + 1，从而将 mid 从搜 索区间排除。
* 最后搜索区间的 l 就是最好的备胎，备胎转正。

#### 代码模板

**Python**

```py

def bisect_right(A, x):
    # 内置 api
    bisect.bisect_right(A, x)
    # 手写
    l, r = 0, len(A) - 1
    while l <= r:
        mid = (l + r) // 2
        if A[mid] <= x: l = mid + 1
        else: r = mid - 1
    return l # 或者返回 r + 1
```

**Java**

```java
import java.util.*;
public class BinarySearch {
    public int getPos(int[] A, int val) {
        int low=0,high=A.lenght-1;
        while (low <= high){
            int mid = (low + high)/2;
            if (A[mid] <= val) {
                low = mid + 1;
            } else {
	    	high = mid - 1;
	    } 
        }
        return low;
    }
}
```

**C++**

```cpp
public:
     int binarySearch(int* arr, int arrLen,int a) {
        int left = 0;
        int right = arrLen - 1;
        while(left<=right)
        {
            int mid = (left+right)/2;
            if(arr[mid]<=a)
	    	// 搜索区间变为 [mid+1, right]
                left = mid + 1;
            else
	    	// 搜索区间变为 [left, mid-1]
                right = mid - 1;
        }  
        return left;
    }
```

**JavaScript**

```js
function binarySearch(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    const mid = Math.floor(left + (right - left) / 2);
    if (nums[mid] <= target) {
    	// 搜索区间变为 [mid+1, right]
    	left = mid + 1;
    }
    else {
    	// 搜索区间变为 [left, mid-1]
    	right = mid - 1;
    }
  }
  return left;
}
```

其他语言暂时空缺，欢迎 [PR](https://github.com/azl397985856/leetcode-cheat/issues/4)

### 局部有序（先降后升或先升后降）

LeetCode 有原题 [33. 搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array/) 和 [81. 搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii/)， 我们直接拿过来讲解好了。

其中 81 题是在 33 题的基础上增加了`包含重复元素`的可能，实际上 33 题的进阶就是 81 题。通过这道题，大家可以感受到”包含重复与否对我们算法的影响“。 我们直接上最复 杂的 81 题，这个会了，可以直接 AC 第 33 题。

#### 81. 搜索旋转排序数组 II

**题目描述**

```
假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
进阶:

这是 搜索旋转排序数组 的延伸题目，本题中的 nums  可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

```

**思路**

这是一个我在网上看到的前端头条技术终面的一个算法题。我们先不考虑重复元素。

题目要求时间复杂度为 logn，因此基本就是二分法了。 这道题目不是直接的有序数组，不 然就是 easy 了。

首先要知道，我们随便选择一个点，将数组分为前后两部分，其中一部分一定是有序的。

具体步骤：

* 我们可以先找出 mid，然后根据 mid 来判断，mid 是在有序的部分还是无序的部分

假如 mid 小于 start，则 mid 一定在右边有序部分，即 \[mid,end] 部分有序。假如 mid 大于 start，则 mid 一定在左边有序部分，即 \[start,mid]部分有序。**这是这类题目的 突破口。**

> 注意我没有考虑等号，之后我会讲。

* 然后我们继续判断 target 在哪一部分， 就可以舍弃另一部分了。

也就是说只需要比较 target 和**有序部分**的边界关系就行了。 比如 mid 在右侧有序部 分，即\[mid,end] 有序。那么我们只需要判断 target >= mid && target <= end 就能知道 target 在右侧有序部分，我们就可以舍弃左边部分了(通过 start = mid + 1 实现)， 反 之亦然。

我们以(\[6,7,8,1,2,3,4,5], 4)为例讲解一下：

![](https://p.ipic.vip/e1eqm5.jpg)

![](https://p.ipic.vip/gmsqw5.jpg)

接下来，我们考虑重复元素的问题。如果存在重复数字，就可能会发生 nums\[mid] == nums\[start] 了，比如 30333 。这个时候可以选择舍弃 start，也就是 start 右移一位。 有的同学会担心”会不会错失目标元素？“。其实这个担心是多余的，前面我们已经介绍了” 搜索区间“。由于搜索区间同时包含 start 和 mid ，因此去除一个 start ，我们还有 mid。假如 3 是我们要找的元素， 这样进行下去绝对不会错过，而是收缩”搜索区间“到一 个元素 3 ，我们就可以心安理得地返回 3 了。

**代码（Python）**

```python
class Solution:
    def search(self, nums, target):
        l, r = 0, len(nums)-1
        while l <= r:
            mid = l + (r-l)//2
            if nums[mid] == target:
                return True
            while l < mid and nums[l] == nums[mid]:  # tricky part
                l += 1
            # the first half is ordered
            if nums[l] <= nums[mid]:
                # target is in the first half
                if nums[l] <= target < nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            # the second half is ordered
            else:
                # target is in the second half
                if nums[mid] < target <= nums[r]:
                    l = mid + 1
                else:
                    r = mid - 1
        return False

```

**复杂度分析**

* 时间复杂度：$O(log N)$
* 空间复杂度：$O(1)$

**扩展**

如果题目不是让你返回 true 和 false，而是返回最左/最右等于 targrt 的索引呢？这不 就又和前面的知识建立联系了么？比如我让你在一个旋转数组中找最左等于 target 的索引 ，其实就是 [面试题 10.03. 搜索旋转数组](https://leetcode-cn.com/problems/search-rotate-array-lcci/)。

思路和前面的最左满足类似，仍然是通过压缩区间，更新备胎，最后返回备胎的方式来实现 。 具体看代码吧。

Python Code:

```py
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        l, r = 0, len(nums) - 1
        while l <= r:
            mid = l + (r - l) // 2
            # # the first half is ordered
            if nums[l] < nums[mid]:
                # target is in the first half
                if nums[l] <= target <= nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            # # the second half is ordered
            elif nums[l] > nums[mid]:
                # target is in the second half
                if nums[l] <= target or target <= nums[mid]:
                    r = mid - 1
                else:
                    l = mid + 1
            elif nums[l] == nums[mid]:
                if nums[l] != target:
                    l += 1
                else:
                    # l 是一个备胎
                    r = l - 1
        return l if l < len(nums) and nums[l] == target else -1

```

### 二维数组

二维数组的二分查找和一维没有本质区别， 我们通过两个题来进行说明。

#### 74. 搜索二维矩阵

**题目地址**

<https://leetcode-cn.com/problems/search-a-2d-matrix/>

**题目描述**

```
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1:

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 3
输出: true
示例 2:

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 13
输出: false

```

**思路**

简单来说就是将一个一维有序数组切成若干长度相同的段，然后将这些段拼接成一个二维数 组。你的任务就是在这个拼接成的二维数组中找到 target。

需要注意的是，数组是不存在重复元素的。

> 如果有重复元素，我们该怎么办？

算法：

* 选择矩阵左下角作为起始元素 Q
* 如果 Q > target，右方和下方的元素没有必要看了（相对于一维数组的右边元素）
* 如果 Q < target，左方和上方的元素没有必要看了（相对于一维数组的左边元素）
* 如果 Q == target ，直接 返回 True
* 交回了都找不到，返回 False

**代码(Python)**

```py


class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        if m == 0:
            return False
        n = len(matrix[0])

        x = m - 1
        y = 0
        while x >= 0 and y < n:
            if matrix[x][y] > target:
                x -= 1
            elif matrix[x][y] < target:
                y += 1
            else:
                return True
        return False

```

**复杂度分析**

* 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $O(M \* N)$。更 多的情况下时间复杂度为 $O(M + N)$
* 空间复杂度：$O(1)$

力扣 [240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) 发生了一点变化，不再是`每行的第一个整数大于前一行的最后一个整数`，而是 `每列的元素从上到下升序排列`。我们仍然可以选择左下进行二分。

### 寻找最值(改进的二分)

上面全部都是找到给定值，这次我们试图寻找最值（最小或者最大）。我们以最小为例，讲 解一下这种题如何切入。

**153. 寻找旋转排序数组中的最小值**

**题目地址**

<https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/>

**题目描述**

```
假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。

示例 1:

输入: [3,4,5,1,2]
输出: 1
示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

```

**二分法**

**思路**

和查找指定值得思路一样。我们还是：

* 初始化首尾指针 l 和 r
* 如果 nums\[mid] 大于 nums\[r]，说明 mid 在左侧有序部分，由于最小的一定在右侧，因 此可以收缩左区间，即 l = mid + 1
* 否则收缩右侧，即 r = mid（不可以 r = mid - 1）

> 这里多判断等号没有意义，因为题目没有让我们找指定值

* 当 l >= r 或者 nums\[l] < nums\[r] 的时候退出循环

> nums\[l] < nums\[r]，说明区间 \[l, r] 已经是整体有序了，因此 nums\[l] 就是我们想要 找的

**代码（Python）**

```py


class Solution:
    def findMin(self, nums: List[int]) -> int:
        l, r = 0, len(nums) - 1

        while l < r:
            # important
            if nums[l] < nums[r]:
                return nums[l]
            mid = (l + r) // 2
            # left part
            if nums[mid] > nums[r]:
                l = mid + 1
            else:
                # right part
                r = mid
        # l or r is not important
        return nums[l]

```

**复杂度分析**

* 时间复杂度：$O(log N)$
* 空间复杂度：$O(1)$

**另一种二分法**

**思路**

我们当然也也可以和 nums\[l] 比较，而不是上面的 nums\[r]，我们发现：

* 旋转点左侧元素**都大于**数组第一个元素
* 旋转点右侧元素**都小于**数组第一个元素

这样就建立了 nums\[mid] 和 nums\[0] 的联系。

具体算法：

1. 找到数组的中间元素 mid。
2. 如果中间元素 > 数组第一个元素，我们需要在 mid 右边搜索。

![](https://p.ipic.vip/e5lrsi.jpg)

* 如果中间元素 <= 数组第一个元素，我们需要在 mid 左边搜索。

上面的例子中，中间元素 6 比第一个元素 4 大，因此在中间点右侧继续搜索。

1. 当我们找到旋转点时停止搜索，当以下条件满足任意一个即可：

* nums\[mid] > nums\[mid + 1]，因此 mid+1 是最小值。
* nums\[mid - 1] > nums\[mid]，因此 mid 是最小值。

![](https://p.ipic.vip/c524lk.jpg)

**代码（Python）**

```py
class Solution:
    def findMin(self, nums):
        # If the list has just one element then return that element.
        if len(nums) == 1:
            return nums[0]

        # left pointer
        left = 0
        # right pointer
        right = len(nums) - 1

        # if the last element is greater than the first element then there is no rotation.
        # e.g. 1 < 2 < 3 < 4 < 5 < 7. Already sorted array.
        # Hence the smallest element is first element. A[0]
        if nums[right] > nums[0]:
            return nums[0]

        # Binary search way
        while right >= left:
            # Find the mid element
            mid = left + (right - left) / 2
            # if the mid element is greater than its next element then mid+1 element is the smallest
            # This point would be the point of change. From higher to lower value.
            if nums[mid] > nums[mid + 1]:
                return nums[mid + 1]
            # if the mid element is lesser than its previous element then mid element is the smallest
            if nums[mid - 1] > nums[mid]:
                return nums[mid]

            # if the mid elements value is greater than the 0th element this means
            # the least value is still somewhere to the right as we are still dealing with elements greater than nums[0]
            if nums[mid] > nums[0]:
                left = mid + 1
            # if nums[0] is greater than the mid value then this means the smallest value is somewhere to the left
            else:
                right = mid - 1

```

**复杂度分析**

* 时间复杂度：$O(log N)$
* 空间复杂度：$O(1)$

### 二叉树

对于一个给定的二叉树，其任意节点最多只有两个子节点。 从这个定义，我们似乎可以嗅 出一点二分法的味道， 但是这并不是二分。但是，二叉树中却和二分有很多联系，我们来 看一下。

最简单的，如果这个二叉树是一个二叉搜索树（BST）。 那么实际上，在一个二叉搜索树种 进行搜索的过程就是二分法。

![](https://p.ipic.vip/bd2rnk.jpg)

如上图，我们需要在这样一个二叉搜索树中搜索 7。那么我们的搜索路径则会是 8 -> 3 -> 6 -> 7，这也是一种二分法。只不过相比于普通的**有序序列查找给定值**二分， 其时间 复杂度的下界更差，原因在于二叉搜索树并不一定是二叉平衡树。

上面讲了二叉搜索树，我们再来看一种同样特殊的树 - 完全二叉树。 如果我们给一颗完全 二叉树的所有节点进行编号（二进制），依次为 01,10,11, ...。

![](https://p.ipic.vip/exnxz6.jpg)

那么实际上，最后一行的编号就是从根节点到该节点的路径。 其中 0 表示向左， 1 表示 向右。(第一位数字不用)。 我们以最后一行的 101 为例，我们需要执行一次左，然后一次 右。

![](https://p.ipic.vip/z5fob9.jpg)

其实原理也不难，如果你用数组表示过完全二叉树，那么就很容易理解。 我们可以发现，左节点的编号都是父节点的二倍，并且右节点都是父节点的二倍 + 1。从二进制的角度来看就是：**父节点的编号左移一位就是左节点的编号，左移一位 + 1 就是右节点的编号**。 因此反过来， 知道了子节点的最后一位，我们就能知道它是父节点的左节点还是右节点啦。

## 题目推荐

* [875. 爱吃香蕉的珂珂](https://leetcode-cn.com/problems/koko-eating-bananas/)
* [300. 最长上升子序列](https://leetcode-cn.com/problems/longest-increasing-subsequence/description/)
* [354. 俄罗斯套娃信封问题](https://leetcode-cn.com/problems/russian-doll-envelopes/)
* [面试题 17.08. 马戏团人塔](https://leetcode-cn.com/problems/circus-tower-lcci/)

> 后面三个题建议一起做

## 总结

二分查找是一种非常重要且难以掌握的核心算法，大家一定要好好领会。有的题目直接二分 就可以了，有的题目二分只是其中一个环节。不管是哪种，都需要我们对二分的思想和代码 模板非常熟悉才可以。

二分查找的基本题型有：

* 查找满足条件的元素，返回对应索引
* 如果存在多个满足条件的元素，返回最左边满足条件的索引。
* 如果存在多个满足条件的元素，返回最右边满足条件的索引。
* 数组不是整体有序的。 比如先升序再降序，或者先降序再升序。
* 将一维数组变成二维数组。
* 局部有序查找最大（最小）元素
* 。。。

不管是哪一种类型，我们的思维框架都是类似的，都是：

* 先定义**搜索区间**（非常重要）
* 根据搜索区间定义循环结束条件
* 取中间元素和目标元素做对比（目标元素可能是需要找的元素或者是数组第一个，最后一 个元素等）（非常重要）
* 根据比较的结果收缩区间，舍弃非法解（也就是二分）

> 如果是整体有序通常只需要 nums\[mid] 和 target 比较即可。如果是局部有序，则可能 需要与其周围的特定元素进行比较。

大家可以使用这个思维框架并结合本文介绍的几种题型进行练习，必要的情况可以使用我提 供的解题模板，提供解题速度的同时，有效地降低出错的概率。

特别需要注意的是**有无重复元素对二分算法影响很大**，我们需要小心对待。


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/91/binary-search.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.