我们前文 我写了首诗，把二分搜索变成了默写题 详细介绍了二分搜索的细节问题，探讨了「搜索一个元素」，「搜索左侧边界」，「搜索右侧边界」这三个情况，教你如何写出正确无 bug 的二分搜索算法。

但是前文总结的二分搜索代码框架仅仅局限于「在有序数组中搜索指定元素」这个基本场景，具体的算法问题没有这么直接，可能你都很难看出这个问题能够用到二分搜索。

所以本文就来总结一套二分搜索算法运用的框架套路，帮你在遇到二分搜索算法相关的实际问题时，能够有条理地思考分析，步步为营，写出答案。

原始的二分搜索代码

二分搜索的原型就是在「有序数组」中搜索一个元素 target，返回该元素对应的索引。

如果该元素不存在，那可以返回一个什么特殊值，这种细节问题只要微调算法实现就可实现。

还有一个重要的问题，如果「有序数组」中存在多个 target 元素，那么这些元素肯定挨在一起，这里就涉及到算法应该返回最左侧的那个 target 元素的索引还是最右侧的那个 target 元素的索引，也就是所谓的「搜索左侧边界」和「搜索右侧边界」，这个也可以通过微调算法的代码来实现。

我们前文 我写了首诗，把二分搜索变成了默写题 详细探讨了上述问题，对这块还不清楚的读者建议复习前文，已经搞清楚基本二分搜索算法的读者可以继续看下去。

在具体的算法问题中，常用到的是「搜索左侧边界」和「搜索右侧边界」这两种场景，很少有让你单独「搜索一个元素」。

因为算法题一般都让你求最值，比如让你求吃香蕉的「最小速度」，让你求轮船的「最低运载能力」，求最值的过程，必然是搜索一个边界的过程，所以后面我们就详细分析一下这两种搜索边界的二分算法代码。

注

注意，本文我写的都是左闭右开的二分搜索写法，如果你习惯两端都闭的写法，可以自行改写代码。

「搜索左侧边界」的二分搜索算法的具体代码实现如下：

// 搜索左侧边界
int left_bound(vector<int>& nums, int target) {
if (nums.size() == 0) return -1;
int left = 0, right = nums.size();

while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
// 当找到 target 时，收缩右侧边界
right = mid;
} else if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid;
}
}
return left;
}

「搜索右侧边界」的⼆分搜索算法的具体代码实现如下：
// 搜索右侧边界
int right_bound(int[] nums, int target) {
if (nums.length == 0) return -1;
int left = 0, right = nums.length;

 while (left < right) {
 int mid = left + (right - left) / 2;

 if (nums[mid] == target) {
 // 当找到 target 时，收缩左侧边界
 left = mid + 1;
 } else if (nums[mid] < target) {
 left = mid + 1;
 } else if (nums[mid] > target) {
 right = mid;
 }
 }
 return left - 1;
}

好，上述内容都属于复习，我想读到这⾥的读者应该都能理解。记住上述的图像，所有能够抽象出上述图像
的问题，都可以使⽤⼆分搜索解决。

⼆分搜索问题的泛化

什么问题可以运⽤⼆分搜索算法技巧？

⾸先，你要从题⽬中抽象出⼀个⾃变量 x，⼀个关于 x 的函数 f(x)，以及⼀个⽬标值 target。

同时，x, f(x), target 还要满⾜以下条件：

1、f(x) 必须是在 x 上的单调函数（单调增单调减都可以）。

2、题⽬是让你计算满⾜约束条件 f(x) == target 时的 x 的值。

上述规则听起来有点抽象，来举个具体的例⼦：

给你⼀个升序排列的有序数组 nums 以及⼀个⽬标元素 target，请你计算 target 在数组中的索引位置，
如果有多个⽬标元素，返回最⼩的索引。

这就是「搜索左侧边界」这个基本题型，解法代码之前都写了，但这⾥⾯ x, f(x), target 分别是什么
呢？

我们可以把数组中元素的索引认为是⾃变量 x，函数关系 f(x) 就可以这样设定：

// 函数 f(x) 是关于⾃变量 x 的单调递增函数
// ⼊参 nums 是不会改变的，所以可以忽略，不算⾃变量
int f(int x, int[] nums) {
 return nums[x];
}

其实这个函数 f 就是在访问数组 nums，因为题⽬给我们的数组 nums 是升序排列的，所以函数 f(x) 就是在
x 上单调递增的函数。

最后，题⽬让我们求什么来着？是不是让我们计算元素 target 的最左侧索引？

是不是就相当于在问我们「满⾜ f(x) == target 的 x 的最⼩值是多少」？

画个图，如下：

如果遇到⼀个算法问题，能够把它抽象成这幅图，就可以对它运⽤⼆分搜索算法。
算法代码如下：

int f(int x, int nums[]) {
return nums[x];
}

int left_bound(int nums[], int target) {
int len = sizeof(nums) / sizeof(nums[0]);
if (len == 0) return -1;

int left = 0, right = len;

while (left < right) {
int mid = left + (right - left) / 2;
if (f(mid, nums) == target) {
// 当找到 target 时，收缩右侧边界
right = mid;
} else if (f(mid, nums) < target) {
left = mid + 1;
} else if (f(mid, nums) > target) {
right = mid;
}
}
return left;
}

这段代码把之前的代码微调了⼀下，把直接访问 nums[mid] 套了⼀层函数 f，其实就是多此⼀举，但是，
这样能抽象出⼆分搜索思想在具体算法问题中的框架。

运⽤⼆分搜索的套路框架
想要运⽤⼆分搜索解决具体的算法问题，可以从以下代码框架着⼿思考：

// 函数 f 是关于自变量 x 的单调函数
int f(int x) {
// ... 函数体实现
}

// 主函数，在 f(x) == target 的约束下求 x 的最值
int solution(int nums[], int target) {
if (sizeof(nums) / sizeof(nums[0]) == 0) return -1;
// 问自己：自变量 x 的最小值是多少？
int left = ...;  // 请根据实际情况填入最小值

// 问自己：自变量 x 的最大值是多少？
int right = ... + 1;  // 请根据实际情况填入最大值

while (left < right) {
int mid = left + (right - left) / 2;
if (f(mid) == target) {
// 问自己：题目是求左边界还是右边界？
// ...根据题目要求填入操作

} else if (f(mid) < target) {
// 问自己：怎么让 f(x) 大一点？
// ...根据题目要求填入操作

} else if (f(mid) > target) {
// 问自己：怎么让 f(x) 小一点？
// ...根据题目要求填入操作
}
}
return left;
}

具体来说，想要⽤⼆分搜索算法解决问题，分为以下⼏步：

1、确定 x, f(x), target 分别是什么，并写出函数 f 的代码。

2、找到 x 的取值范围作为⼆分搜索的搜索区间，初始化 left 和 right 变量。

3、根据题⽬的要求，确定应该使⽤搜索左侧还是搜索右侧的⼆分搜索算法，写出解法代码。

下⾯⽤⼏道例题来讲解这个流程。