LeetCode 704. 二分查找:思路、循环不变式、复杂度与复用边界
标签:
LeetCode二分查找C++算法循环不变式
难度:简单
题目链接:LeetCode 704. 二分查找
目录
一、题目与代码
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target,搜索 nums 中的 target:存在返回下标,否则返回 -1。要求时间复杂度 O(log n)。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
题目给出的代码:
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0, right = nums.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (target < nums[mid]) right = mid - 1;
else if (target > nums[mid]) left = mid + 1;
else return mid;
}
return -1;
}
};
先给结论:
- 思路:利用有序性,每次比较
nums[mid]后排除一半元素;用闭区间[left, right]表示"还可能存在答案"的范围。 - 结束条件:
left > right,即区间为空。 - 正确性:靠循环不变式——“若
target存在,其下标必在[left, right]内”。 - 复杂度:时间
O(log n),额外空间O(1)。 - 复用:有序 + 随机访问 + 静态数据 + 只查"是否存在"时可原样套;涉及上下界、二分答案时要换模板,且区间定义、循环条件、边界更新三处必须同时改。
- 何时想到:看到"有序 + 查找 + O(log n)“是显性信号;更本质的信号是"答案具有单调性、可用
check(x)判定”,这时二分的是答案值域而不是数组下标。
二、思路分析:有序到底带来了什么
2.1 从线性扫描到一次砍一半
最直接的做法是从头到尾扫一遍,逐个比较:
for (int i = 0; i < nums.size(); i++)
if (nums[i] == target) return i;
时间复杂度 O(n)。问题在于:它每次只排除了一个元素,完全没有利用"数组有序"这个条件。
有序意味着什么?取任意中点 mid,数组被切成三段:
nums[0 .. mid-1] nums[mid] nums[mid+1 .. n-1]
都 <= nums[mid] 比较值 都 >= nums[mid]
把 target 和 nums[mid] 比较,只有三种结果:
target == nums[mid]:找到了,直接返回mid。target < nums[mid]:由于右边所有元素都>= nums[mid] > target,整个右半段(包括mid)都不可能是答案,答案只可能在左半段。target > nums[mid]:对称,整个左半段(包括mid)都不可能是答案,答案只可能在右半段。
关键就在第 2、3 种情况:一次比较排除的不是一个元素,而是一半的元素。这就是 O(log n) 的来源。
2.2 用区间描述"还没被排除的范围"
为了把"排除"这件事写清楚,引入两个指针:
| 变量 | 含义 |
|---|---|
left | 当前搜索区间的左端点(包含) |
right | 当前搜索区间的右端点(包含) |
mid | 区间中点,向下取整 |
| 搜索区间 | 闭区间 [left, right] |
一句话:[left, right] 就是"目前还没有被排除、仍可能是答案"的下标集合。
这个语义非常重要。之后所有的边界更新,本质上都只是在做一件事:把已经确定不可能是答案的位置,从区间里踢出去。
target < nums[mid]时,mid及其右边全部出局:right = mid - 1。target > nums[mid]时,mid及其左边全部出局:left = mid + 1。
注意这里用的是 mid - 1 和 mid + 1,而不是 mid。因为 nums[mid] 已经在本次比较中被判定为"不等于 target",它没有资格继续留在候选区间里。
2.3 把两个示例走一遍
示例 1:nums = [-1,0,3,5,9,12],target = 9
| 轮次 | left | right | mid | nums[mid] | 判断与动作 |
|---|---|---|---|---|---|
| 1 | 0 | 5 | 2 | 3 | 9 > 3,排除左半,left = 3 |
| 2 | 3 | 5 | 4 | 9 | 相等,返回 4 |
示例 2:nums = [-1,0,3,5,9,12],target = 2
| 轮次 | left | right | mid | nums[mid] | 判断与动作 |
|---|---|---|---|---|---|
| 1 | 0 | 5 | 2 | 3 | 2 < 3,排除右半,right = 1 |
| 2 | 0 | 1 | 0 | -1 | 2 > -1,排除左半,left = 1 |
| 3 | 1 | 1 | 1 | 0 | 2 > 0,排除左半,left = 2 |
| 结束 | 2 | 1 | — | — | left > right,区间为空,返回 -1 |
第 3 轮很关键:left == right == 1 时区间里还剩最后一个元素 nums[1] = 0,必须把它检查完,才能断定 target 不存在。这也是下一节"循环条件为什么是 <="的直接原因。
2.4 mid 为什么写成 left + (right - left) / 2
它和 (left + right) / 2 在数学上等价,区别只在溢出:
left + right可能超过int的上限(当数组很大、left和right都接近INT_MAX时),加法先溢出,再除以 2 就得到负数,mid直接越界。right - left是两个下标之差,不会超过数组长度,先减后加不会溢出。
本题 n <= 10000,两种写法都不会溢出。但这是一个应该养成的习惯:只要写二分,就用 left + (right - left) / 2。在 Java 里对应 (left + right) >>> 1,在 Python 里因为整数不会溢出才无所谓。
另外,这个写法是向下取整:当区间长度 L = right - left + 1 时,mid = left + (L - 1) / 2,满足 left <= mid <= right。这一点在分析死循环时还会用到。
三、循环结束的条件
3.1 语法层:left > right
while (left <= right) { ... }
循环体执行的条件是 left <= right,所以循环结束的条件就是它的否定:
left > right
因为 left 和 right 都是整数,left > right 等价于 left >= right + 1,也就是 left == right + 1(在本题的更新方式下,两者不会跳得更远)。
3.2 语义层:区间为空
闭区间 [left, right] 非空的条件是 left <= right。所以:
循环结束 ⇔
left > right⇔ 闭区间[left, right]为空 ⇔ 没有任何下标还可能是答案。
再由循环不变式(下一节证明):如果 target 真的存在,它的下标一定在 [left, right] 里。现在区间是空的,它不可能在空区间里,所以 target 不存在,返回 -1 是正确的。
这就是"循环结束条件"的两层含义:语法上是 left > right,语义上是"候选集合为空"。 写二分时真正要盯住的是后者。
3.3 为什么必须是 <=,不能是 <
假设把循环条件改成 while (left < right),仍然使用闭区间和 mid ± 1 的更新方式:
while (left < right) { // 错误写法
int mid = left + (right - left) / 2;
if (target < nums[mid]) right = mid - 1;
else if (target > nums[mid]) left = mid + 1;
else return mid;
}
return -1;
反例:nums = [5],target = 5。
- 初始
left = 0, right = 0。 left < right为假,循环一次都不执行。- 直接返回
-1,但正确答案是0。
问题在于:left == right 时区间里还有一个元素没被检查,此时结束循环就等于把它漏掉了。闭区间模板必须配 <=,让区间长度为 1 时仍然进入循环,把这个元素检查完。
记忆方式:闭区间
[left, right]的"非空"条件是left <= right,循环条件就应该和它完全一致。
3.4 为什么不会死循环
每轮循环只有三种出路:
target == nums[mid]:直接return mid,循环结束。target < nums[mid]:right = mid - 1 < right(因为mid <= right,所以mid - 1 <= right - 1),右端点严格左移。target > nums[mid]:left = mid + 1 > left(因为mid >= left),左端点严格右移。
只要不返回,区间长度 L = right - left + 1 每轮都严格减小。L 是非负整数,不可能无限减小下去,所以循环一定在有限步内结束。更精确地说,每轮至少折半,这一点在复杂度一节给出。
3.5 循环结束时,left 和 right 分别是什么
这是一个经常被忽略、但非常有用的事实。
循环结束时 left == right + 1。由不变式可以推出更强的结论:
nums[0 .. left-1]全部小于target;nums[right+1 .. n-1]全部大于target。
所以(在 target 不存在的情况下):
nums[left]是第一个大于target的元素(如果left < n);nums[right]是最后一个小于target的元素(如果right >= 0);left恰好是target应该被插入的位置。
本题把这个信息丢掉了(直接 return -1),但在 LeetCode 35. 搜索插入位置 里,只需要把最后的 return -1 改成 return left,代码就能直接通过(LC35 保证元素不重复,所以提前返回的下标也是唯一的)。
这也说明:二分查找即使"没找到",
left/right也不是废信息,它们定位了目标应该出现的位置。后面讲lower_bound时会反复用到这一点。
四、为什么是正确的
4.1 循环不变式
要证明一个带循环的算法正确,最干净的工具是循环不变式(loop invariant)。对本题,取:
不变式 I:在每轮循环开始时,如果
target存在于nums中,那么它的某个下标一定落在闭区间[left, right]内。等价说法:
nums[0 .. left-1]和nums[right+1 .. n-1]中没有任何元素等于target。
然后验证三件事:初始化成立、每轮保持、终止时能推出结论。
4.2 初始化:第一次进入循环前成立
初始 left = 0, right = n - 1,区间就是整个数组 [0, n-1]。区间外没有任何下标,所以"区间外不含 target"是空真命题。若 target 存在,它的下标当然在 [0, n-1] 内。不变式成立。
4.3 保持:每轮更新后仍然成立
设本轮开始时不变式成立,令 mid = left + (right - left) / 2,则 left <= mid <= right。
-
情况一:
target == nums[mid]。 直接返回mid,算法结束,不需要再保持不变式。 -
情况二:
target < nums[mid]。 因为数组升序,对所有j >= mid都有nums[j] >= nums[mid] > target所以
[mid, right]里的所有下标都不可能是答案。把right更新为mid - 1后,新区间是[left, mid-1],而刚刚被踢出去的[mid, old_right]正好都满足"不等于target"。如果target存在,它只能在新区间里。不变式保持。 -
情况三:
target > nums[mid]。 对称地,对所有j <= mid都有nums[j] <= nums[mid] < target所以
[left, mid]都不可能是答案。令left = mid + 1,新区间是[mid+1, right],被排除的部分都不含target。不变式保持。
4.4 终止:循环结束时结论成立
循环结束时 left > right,闭区间 [left, right] 为空。
反证:假设 target 存在。由不变式,它的下标必在 [left, right] 内;但该区间为空,矛盾。所以 target 不存在,返回 -1 正确。
如果 target 存在,由不变式,它的下标始终留在区间里;而区间每轮严格缩小,最终长度变为 1。此时 mid 就是区间里唯一的下标,也就是 target 的下标,下一轮必然命中并返回。两种情况合起来,算法正确。
4.5 "元素不重复"其实不是必需的
回头看上面的证明,只用到了升序(更准确地说,是非降序),没有用到"元素不重复"。
- 对"是否存在"这个问题,重复元素完全不影响正确性:区间里只要有一个等于
target的元素,早晚会被mid命中。 - 重复元素影响的是"返回哪一个":本模板可能返回任意一个等于
target的下标,不保证是第一个,也不保证是最后一个。 - 题目之所以给"不重复",是为了让答案唯一、方便判题,而不是算法本身的要求。
这个区分很重要:一旦题目要求"第一个等于 target"或"最后一个等于 target",本题代码就不能直接用了,必须换成下一节的上下界模板。
4.6 边界情况逐一验证
n = 1:left = right = 0,mid = 0。相等返回0;否则left = 1或right = -1,循环结束返回-1。正确。target比所有元素都小:每轮都执行right = mid - 1,最终right变成-1,left保持0,left > right结束。mid不会变成负数(mid >= left >= 0)。正确。target比所有元素都大:每轮left = mid + 1,最终left = n,right = n - 1,结束。mid不会越界(mid <= right <= n-1)。正确。target在下标0或n-1:第一轮或最后一轮命中,返回正确下标。- 空数组
n = 0:本题约束n >= 1不会出现。但工程代码里要注意nums.size() - 1的size_t下溢问题(见第八节)。
五、复杂度
5.1 时间复杂度:O(log n)
设某轮开始时区间长度为
L = right - left + 1
mid = left + (L - 1) / 2(向下取整)。比较后,剩下的一半长度分别为:
左半段长度 = mid - left = (L - 1) / 2
右半段长度 = right - mid = L - 1 - (L - 1) / 2 = ceil((L - 1) / 2)
两者取较大者:
L' = ceil((L - 1) / 2) = floor(L / 2)
也就是说,每轮最坏情况下区间长度至少减半。于是第 k 轮后:
L_k <= floor(n / 2^k)
循环在 L = 0 时结束,需要 floor(n / 2^k) = 0,即 2^k > n,所以
k >= floor(log2 n) + 1 = ceil(log2(n + 1))
即最多进行 ceil(log2(n + 1)) 轮,每轮 O(1) 次比较,总时间复杂度:
O(log n)
用递推式写就是:
T(n) = T(n / 2) + O(1) => T(n) = O(log n)
也可以从"判定树"的角度理解:每次取 mid 相当于把当前区间当作一棵二叉搜索树的根,比较结果决定走左子树还是右子树。一次查找就是从根走到某个叶子,最多走一条长度为树高的路径;n 个结点的平衡二叉树高度是 ceil(log2(n + 1)),所以最多比较这么多次。
具体数字感受一下:
n | 线性查找最坏次数 | 二分查找最坏次数 |
|---|---|---|
| 10 | 10 | 4 |
| 100 | 100 | 7 |
| 1,000 | 1,000 | 10 |
| 10,000 | 10,000 | 14 |
| 1,000,000 | 1,000,000 | 20 |
n = 10000 时,线性查找最坏要比较 10000 次,二分只要 14 次,差距三个数量级。
补充两点:
- 最好情况是
O(1):第一次mid就命中。但算法分析看最坏情况,所以结论仍是O(log n)。 - 大
O记号下对数的底数不影响结果,log2 n、ln n、lg n只差常数倍,统一写成O(log n)。
5.2 空间复杂度:O(1)
只用了 left、right、mid 三个整型变量,与 n 无关,额外空间 O(1)。
如果写成递归版本,递归深度是 O(log n),空间复杂度会变成 O(log n)(函数调用栈)。所以本题更推荐迭代写法。
5.3 和线性查找的取舍
二分的前提是"有序"。如果数据本来无序,为了二分而排序是 O(n log n),比直接线性扫描 O(n) 还慢。所以:
- 只查一次、数据无序:线性扫描
O(n)更划算。 - 查很多次、数据静态:排序一次
O(n log n),之后每次查询O(log n),查询次数多时优势明显。 - 只判断存在性:哈希表平均
O(n + m)(m次查询)往往更快,但会丢失有序信息,无法做范围查询和上下界查询。
六、哪些地方可以复用(以及复用的前提)
"复用"要分三个层级来看,条件完全不同:
- 代码原样复用:把这段
search直接搬到另一道题。 - 模板骨架复用:保留"区间 + 循环 + 收缩"的骨架,但改判定条件和边界更新。
- 思想复用:把"在有序数组上二分"升级为"在单调判定空间上二分"(二分答案)。
6.1 代码原样复用的前提
必须同时满足以下条件,这段代码才能不改一行直接使用:
- 单调性:数据按参与比较的键非降序排列(升序)。降序也能用,但要把
target < nums[mid]和target > nums[mid]两个分支对调,或者把访问顺序反过来。 - 随机访问:容器支持
O(1)下标访问,例如vector、array、string、内置数组。链表不行——定位mid就要O(n),二分总复杂度会退化到O(n),还不如直接遍历。 - 查询语义是"存在则返回任意一个下标":有重复元素时,本模板返回值不保证是第一个或最后一个。若题目要求"第一个/最后一个",见 6.2。
- 数据是静态的:构建后不频繁插入、删除。若需要在有序数组中动态插入,单次插入是
O(n),维护成本可能超过二分带来的收益;此时应考虑平衡树、有序集合等结构。 - 比较代价低:每次比较是
O(1)。如果元素是长字符串或大对象、比较很昂贵,要先评估比较次数带来的常数,或者先建索引/哈希。 - 比较关系是全序:
target与元素之间可以直接比较,且比较满足严格弱序(不会出现a < b、b < a、a == b同时为假以外的不一致情况)。 - 长度安全:
n在int能表示的范围内,且n >= 1(或做了空数组保护)。
可以原样复用的典型题目:
- LeetCode 704 二分查找(本题)
- LeetCode 35 搜索插入位置(把
return -1改成return left,前提是元素无重复) - LeetCode 374 猜数字大小(比较对象换成了
guess(),骨架不变) - 任何"有序数组 + 判断某个值是否存在"的场景
6.2 必须换模板的常见变体
一旦需求从"是否存在"变成"第一个/最后一个/插入位置",mid ± 1 的写法就不够用了。核心区别是:当 nums[mid] 可能本身就是答案时,不能把它排除,因此边界要收缩到 mid 而不是 mid ± 1。
下面这些模板和本题一样,都要求数据有序、支持 O(1) 随机访问,区别只在区间语义和收缩方式。
6.2.1 lower_bound:第一个 >= target 的位置
// 返回第一个 >= target 的下标;若全部小于 target,返回 n
int lowerBound(const vector<int>& nums, int target) {
int left = 0, right = (int)nums.size(); // 半开区间 [left, right)
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) left = mid + 1; // mid 及左边都 < target
else right = mid; // mid 可能是答案,保留
}
return left;
}
为什么这里换成了半开区间 [left, right) 和 left < right?
- 答案可能是
n(所有元素都小于target),所以初始right取n,而不是n - 1。 nums[mid] >= target时,mid本身可能就是第一个满足条件的位置,不能排除,所以right = mid,而不是mid - 1。- 半开区间的"空"是
left == right,所以循环条件用<。 - 循环结束时
left == right,这个位置就是答案。
6.2.2 upper_bound:第一个 > target 的位置
// 返回第一个 > target 的下标;若全部 <= target,返回 n
int upperBound(const vector<int>& nums, int target) {
int left = 0, right = (int)nums.size(); // [left, right)
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] <= target) left = mid + 1; // mid 及左边都 <= target
else right = mid; // mid 可能是答案,保留
}
return left;
}
和 lower_bound 只差一个 =:判断条件从 < target 变成 <= target。
6.2.3 用上下界组合出"第一个/最后一个等于 target"
// 第一个等于 target 的下标,不存在返回 -1
int firstEqual(const vector<int>& nums, int target) {
int lb = lowerBound(nums, target);
if (lb < (int)nums.size() && nums[lb] == target) return lb;
return -1;
}
// 最后一个等于 target 的下标,不存在返回 -1
int lastEqual(const vector<int>& nums, int target) {
int ub = upperBound(nums, target);
if (ub > 0 && nums[ub - 1] == target) return ub - 1;
return -1;
}
- 第一个
== x:lower_bound(x),再检查该位置是否真的等于x。 - 最后一个
== x:upper_bound(x) - 1,再检查该位置是否真的等于x。 - 最后一个
<= x:upper_bound(x) - 1。 - 第一个
>= x:lower_bound(x)。
6.2.4 各模板对照表
| 目标 | 区间 | 循环条件 | 收缩方式 | 返回值 |
|---|---|---|---|---|
| 存在性(本题) | [l, r] 闭 | l <= r | l = mid+1 / r = mid-1 | mid 或 -1 |
第一个 >= x | [l, r) 半开 | l < r | r = mid / l = mid+1 | l |
第一个 > x | [l, r) 半开 | l < r | r = mid / l = mid+1 | l |
第一个 == x | 借助 lower_bound | — | — | lb(校验后) |
最后一个 == x | 借助 upper_bound | — | — | ub-1(校验后) |
最后一个 <= x | 借助 upper_bound | — | — | ub-1 |
最重要的复用规则:区间定义、循环条件、边界更新,三者必须同时改、互相对应。
- 闭区间
[l, r]配l <= r,排除mid时用mid ± 1。- 半开区间
[l, r)配l < r,保留mid时用r = mid。- 只改其中一处,轻则漏元素,重则死循环。
6.3 二分答案:最值钱的复用
比"复用代码"更值钱的是"复用思想"。很多题目的数组本身无序,但答案具有单调性,这时二分的对象不是数组下标,而是答案的取值空间。
骨架如下(找第一个满足 check 的位置):
// 前提:check 在 [lo, hi] 上单调(false...false,true...true),且至少有一个 true
int binarySearchFirstTrue(int lo, int hi) {
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (check(mid)) hi = mid; // mid 可行,答案在 [lo, mid]
else lo = mid + 1; // mid 不可行,答案在 [mid+1, hi]
}
return lo;
}
找最后一个满足 check 的位置:
// 前提:check 单调,且至少存在一个 true
int binarySearchLastTrue(int lo, int hi) {
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2; // 上取整,避免死循环
if (check(mid)) lo = mid; // mid 可行,答案在 [mid, hi]
else hi = mid - 1; // mid 不可行,答案在 [lo, mid-1]
}
return lo;
}
注意 mid 取整方向与收缩方式的配对:
mid向下取整时,用lo = mid + 1(否则lo = mid会在区间长度为 2 时原地打转)。mid向上取整时,用lo = mid(此时mid > lo,能保证前进)。- 记不住就记一句话:只要某个分支写
lo = mid,mid就必须向上取整。
二分答案的三步:
- 确定答案范围
[lo, hi]:最小可能值到最大可能值。 - 写
check(x):判断"答案为x时是否可行",要求它关于x单调。 - 确定要找"第一个 true"还是"最后一个 true",选对应模板。
典型题目:
| 题目 | 二分的对象 | check(x) 的含义 |
|---|---|---|
| LC 875 爱吃香蕉的珂珂 | 吃香蕉速度 | 以速度 x 能否在 h 小时内吃完 |
| LC 1011 在 D 天内送达包裹 | 船的最小载重 | 载重 x 能否在 D 天内运完 |
| LC 410 分割数组的最大值 | 子数组和的上限 | 上限为 x 时能否分成 k 段 |
| LC 69 x 的平方根 | 平方根的值 | mid * mid <= x |
| LC 33 搜索旋转排序数组 | 数组下标 | 哪一半是有序的,答案是否在其中 |
| LC 162 寻找峰值 | 数组下标 | nums[mid] < nums[mid+1] 则右侧必有峰 |
| LC 34 排序数组中查找第一个和最后一个位置 | 数组下标 | 上下界 |
6.4 不能复用 / 不该用二分的场景
- 无序 + 只查一次:线性扫描
O(n)或哈希O(n),比"排序 + 二分"的O(n log n)更快。 - 无序 + 多次查询:可以先排序再二分,总代价
O(n log n + m log n);m较大时通常比每次线性扫描O(mn)划算。但如果只需要判断存在性,哈希表平均O(n + m)往往更优——二分真正的优势是"有序"带来的范围查询和上下界能力。 - 动态数据集:频繁插入、删除时,维护有序数组的代价是
O(n)每次;应改用平衡树、有序集合、树状数组等结构。 - 链表或流式数据:不支持
O(1)随机访问,二分失去意义(跳表是例外,它用多级索引换来了近似随机的访问)。 - 需要枚举所有解:二分只能定位一个位置或一个最优值,不能枚举全部方案。
- 判定函数不单调:例如一般图上的最长路径、没有单调约束的子集和,
check(x)的真假会来回跳,二分不成立。 - 需要"第一个/最后一个"却直接套本题代码:会返回任意一个匹配位置,答案错误。
6.5 复用前的自检清单
每次从"本题代码"迁移到"新题"时,按顺序问自己:
- 数据真的有序吗? 排序用的键和比较用的键是同一个吗?(结构体按字段 A 排序、却按字段 B 比较,是经典 bug。)
mid位置在本次判断后能不能排除? 能排除用mid ± 1;不能排除(它可能是答案)用mid。- 区间是闭的还是半开的? 循环条件和它匹配吗?
- 答案会落在初始区间外吗? 例如
lower_bound的答案可能是n,所以初始right必须取n。 - 有重复元素吗? 需要第一个、最后一个,还是任意一个?
left + right会溢出吗? 用left + (right - left) / 2规避。- 循环一定会终止吗? 每轮区间是否严格变小?有没有
lo = mid配下取整这种原地打转的组合? - 空数组、单元素、目标在两端这些边界,代码都覆盖了吗?
七、这种二分法在什么情况下才会想到用
7.1 显性信号:题目把"二分"写在脸上
- 数组有序(升序或降序),或排序后有序;
- 要求时间复杂度
O(log n); - 关键词:查找、搜索、插入位置、第一个、最后一个、上界、下界;
- 有序矩阵中查找(LC 74);
- 旋转排序数组中查找(LC 33、LC 81);
- “在排序数组中查找元素的第一个和最后一个位置”(LC 34)。
这些情况下,二分几乎是条件反射。
7.2 隐性信号:有序不是必要条件,"单调 + 可判定"才是
这是更重要、也更容易被忽略的一层。二分的本质不是"数组有序",而是:
存在一个判定函数
check(x),它的结果关于x单调;并且给定x后,能在可接受的复杂度内算出check(x)。
一旦满足这个条件,就可以对答案的取值空间二分,而不是对数组下标二分。常见问法:
- “最小化最大值” / “最大化最小值”:把"最大值/最小值"当作
x去猜,check(x)判断"能否在限制下做到不超过/不少于x"; - “最少需要多少时间/容量/速度/人力”:猜这个量,判断可行性;
- “第 k 小 / 第 k 大”:二分值域,统计"小于等于
x的有多少个",计数关于x单调; - “答案是一个整数,范围可界定,直接枚举超时”:二分答案;
- “直接构造答案很难,但验证一个答案很容易”:这是二分答案最典型的特征。
一个很实用的自问:
“如果我已经知道答案是
x,我能不能在O(n)或O(log n)内判断它行不行?这个判断会不会随着x变大而从’不行’变成’行’(或反过来)?”
如果两个答案都是"能",那就应该考虑二分答案。
7.3 “有序"可以放宽为"二段性”
二分并不要求整个数组全局有序,只要求每次比较能确定答案在哪一侧。这类问题通常具有"局部单调"或"二段性":
- 旋转排序数组(LC 33):
mid把数组分成两半,至少有一半是有序的;判断target是否在有序的那一半里,就能决定走哪边。 - 寻找峰值(LC 162):
nums[mid] < nums[mid+1]说明右侧一定有峰,否则左侧一定有峰。数组不是全局有序的,但"往高处走"的方向是确定的。 - 山脉数组(LC 852、LC 1095):先增后减,峰值两侧各自单调。
- 寻找旋转排序数组中的最小值(LC 153):比较
nums[mid]与nums[right],判断最小值在左半还是右半。
这些题目的共同点是:比较一次,就能排除一半,并且被排除的那一半确实不含答案。 这才是二分能用的根本条件,比"数组有序"更一般。
7.4 不该想到二分的时候
check(x)不单调,真假交替出现;- 需要输出具体方案,而不仅仅是"最优值是多少"(二分只能定位值,方案要另外构造);
- 数据无序、只查一次,且没有排序需求;
- 数据规模很小,
O(n)已经足够; - 需要动态维护有序性,且插入删除频繁;
- 容器不支持随机访问(链表、流)。
7.5 一个判断口诀
有序数组找位置,直接二分;
答案单调可验证,二分答案;
无序、动态、要方案,先想别的。
八、常见错误清单
mid = (left + right) / 2溢出。本题范围小不会触发,但换到大数组会;统一用left + (right - left) / 2。while (left < right)配闭区间,漏掉最后一个元素。反例:nums = [5], target = 5,直接返回-1。right = mid配while (left <= right),死循环。反例:nums = [1,2], target = 0:l=0, r=1, mid=0,nums[0]=1 > 0,right = mid = 0;l=0, r=0, mid=0,nums[0]=1 > 0,right = mid = 0;- 无限循环。
left = mid配下取整,区间长度为 2 时死循环。反例:nums = [1,2], target = 2,l=0, r=1, mid=0,nums[0] < 2,若写left = mid,则left永远是 0。- 返回值混淆:
lower_bound返回的是left,不是mid;mid只是循环里的临时变量。 - 有重复元素却以为返回的是第一个。本模板只保证"返回某一个等于
target的下标"。 nums.size() - 1的size_t下溢。nums.size()是size_t(无符号),当n = 0时nums.size() - 1会回绕成SIZE_MAX,再赋给int是实现定义行为。本题约束n >= 1不会触发,但工程代码建议写成int n = (int)nums.size(); int right = n - 1;,并提前处理空数组。- 排序键与比较键不一致:按
A排序、按B比较,二分的前提直接被破坏。 - 循环内修改数组:在二分过程中改变元素值或容器结构,导致有序性失效。
- 浮点二分不设终止条件:
while (left <= right)对浮点数可能永远不结束(精度极限),应固定迭代次数(如 100 次)或用right - left > eps且注意eps的选取。 - 把"找第一个"写成"找到就返回":提前
return mid会破坏"第一个"的语义,必须用上下界模板。
一个更稳妥的工程写法:
class Solution {
public:
int search(const vector<int>& nums, int target) {
int n = static_cast<int>(nums.size());
if (n == 0) return -1;
int left = 0, right = n - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) return mid;
if (nums[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
};
改动只有两处:参数加上 const(表明不修改数组)、先取 n 再算 right(避免无符号下溢)。比较顺序调整成先判相等,语义更直观,和"三分支"写法完全等价。
九、总结
9.1 一页纸
| 问题 | 答案 |
|---|---|
| 核心思路 | 有序 → 每次比较排除一半;闭区间 [left, right] 表示候选集合 |
| 循环条件 | left <= right(区间非空);结束于 left > right(区间为空) |
| 为什么正确 | 循环不变式:target 若存在必在区间内;初始化、保持、终止三步 |
| 时间复杂度 | 每轮区间折半,ceil(log2(n+1)) 轮,O(log n) |
| 空间复杂度 | O(1) |
| 能否原样复用 | 有序 + 随机访问 + 静态 + 只查存在性 + 比较 O(1) |
| 换模板的信号 | 上下界、第一个/最后一个、二分答案 |
| 换模板的铁律 | 区间、循环条件、边界更新三处同改 |
| 何时想到二分 | 有序/查找/O(log n),或"答案单调 + 可判定" |
| 何时不该用 | 无序单次查询、动态数据、判定不单调、需要枚举方案 |
9.2 最后三句话
- 二分不是"背模板",而是"维护一个候选区间"。 写之前先写清楚区间是什么、空区间长什么样、每次排除哪一半,代码自然就对了。
mid ± 1和mid的区别,本质是"这个位置有没有被判定过"。 判定过就排除(±1),没判定、且可能是答案就保留(mid)。- 最强的复用不是抄代码,而是识别"单调性"。 只要能把问题写成"猜一个
x,判断行不行,且可行性随x单调",二分就能从"数组查找"扩展到"答案搜索",适用范围会大一个量级。
9463



被折叠的 条评论
为什么被折叠?



