LeetCode 35 深入解析:二分查找与 lower_bound 的边界之美
1. 道理我都懂,就是写不对——LeetCode35 的题面陷阱
LeetCode 35这道题在题库里标注的是"简单",我看过不少刷题打卡群里的人,第一天做数组题做到它,大概三分钟就能把"遍历找到就返回、找不到就返回应该插入的位置"这个思路说出来。但真把这段逻辑写成代码,提交的时候,反而有一批人会挂在边界条件上。
题目原文很简单:给定一个排序数组(升序、无重复)和一个目标值,在数组中找到目标值,如果找到就返回下标,如果找不到,返回它按顺序插入后应该处在的位置下标。要求时间复杂度是 O(log n)。
很多人一开始会懵一下:数组是有序的,但"顺序插入的位置"到底怎么定义?比如 nums = [1,3,5,6],target = 2,答案是 1,因为 2 应该插在 1 和 3 之间,下标就是 1。如果 target = 7,答案是 4,插在数组末尾。如果 target = 0,答案是 0,插在数组开头。
这个描述,其实把两个问题揉在一起了:
- 能不能在数组里直接找到 target,如果能,返回它的下标;
- 如果不能,返回它应该在的位置,这个"应该在的位置"正是数组中第一个大于 target 的元素下标,如果所有元素都比 target 小,就返回数组长度。
麻烦就麻烦在"搜索"和"插入位置"这两个词放在一起。搜索,我们本能会想到二分;插入位置,很多人又会往"往哪插"这个方向上想。实际上这道题要的是一个统一的结论:返回第一个大于等于 target 的下标。
有了这个结论,你再看那些示例,会发现它其实就是问你,在一个有序数组里,用 O(log n) 找到 target 插入后应有的位置。这个位置既是"找到 target 时的下标",也是"没找到时插入后的下标"。一句话概括就是:lower_bound / bisect_left 的结果。
这是整道题最关键的一步,一定要把题面翻译成"找第一个大于等于 target 的索引"。翻译对了,后面写二分只是在处理各种细节而已。接下来我会从暴力解法开始,一步步把这个问题拆干净。
2. 暴力解法:思路没问题,复杂度对不起题目
先写最直接的思路,当做一个"审视题面的基准"。
暴力解法分两种情况讨论。第一种,遍历数组,如果某个元素等于 target,返回它的下标。第二种,如果遍历完都没找到,那就找第一个大于 target 的元素,插入在它前面。代码可能长这样(Python):
有没有发现,上面这段代码根本不用分两种情况。因为如果 target 存在,第一个大于等于 target 的元素就是 target 本身,返回的就是它的下标;如果不存在,第一个大于等于 target 的元素就是"该插入位置之后的那个元素";如果 target 比所有元素都大,循环结束后返回 len(nums)。
这段代码跑示例是完全没问题的,而且它做到了一件很重要的事:把"找到 target 的下标"和"找到插入位置"统一成了同一个逻辑,也就是前面说的"第一个大于等于 target 的下标"。
但它的问题也很明显:时间复杂度是 O(n)。题目明确要求 O(log n),这个解法在 LeetCode 上能过(因为数据量不大),但面试官一定会继续问:你的题解时间复杂度是多少?还能优化吗?
这种时候你答"再想想",然后切到二分,是比较标准的面试剧本。不过,暴力解法最大的价值不是"能过就行",而是它用最朴素的方式点出了这道题的本质——我们要找的是一个边界,不是某个具体元素。
为什么这么说?因为如果题目只是"找 target 的下标",那二分模板里判断等号就好。但现在多了"插入位置"这层含义,就意味着 target 本身可能不存在于数组中,我们必须找到一个通用的"落点"。
所以,暴力解法的另一个意义,就是验证你后面写二分时的心智模型对不对。你先写出了"第一个大于等于 target 的元素下标",再写二分时,所有的分支判断都要围绕这个条件展开,而不是围绕"nums[mid] == target"展开。
提示:如果你做这题时想的还是"遍历一遍,相等返回,否则找插入位置",我建议你先别急着上二分。先在纸上把"第一个大于等于 target"这个定义写三遍,直到你看到这道题的第一反应不再是"相等判断",而是"边界查找"。
3. 二分查找的"题眼":把问题翻译成找左边界
从暴力解法到二分查找,缺的并不是"有序数组就要二分"这个直觉,而是需要想明白一个问题:二分查找每一步缩小区间时,我们到底在维护什么?
如果你写的是"找到 target",那当你得到一个 nums[mid] == target 时,你可能会想:找到了,直接返回 mid。这没错,但在本题里,这个思维会埋雷。因为 "== target" 只是"插入位置"的一种情况,当 target 不存在时,你还是得退回来找"第一个大于 target"的位置,你能确定 mid 左边没有漏掉比 target 大的元素吗?
所以更合理的做法是,把问题重新定义为:在有序数组中,找第一个满足 nums[i] >= target 的 i。这个位置,就是答案。
这个定义有两个好处。第一,它把所有可能的情况统一成了一句话:target 在数组中,答案是它的下标;target 不在数组中,答案是它该插入的下标;target 比所有元素大,答案是数组长度。第二,它非常契合二分的"区间收缩"逻辑:我们维护一个边界,把所有小于 target 的元素排除在候选答案之外,把所有大于等于 target 的元素保留下来。
换句话说,你可以把数组想象成两段:左边全是 < target 的,右边全是 >= target 的。我们要找的,就是这两段交界处那第一个 >= target 的下标。这个"交界处",学名一般叫 lower_bound。
为什么强调"第一个"?因为数组是无重复的,在本题里">= target"的元素只可能有一个等于 target。但在扩展场景里,比如 LeetCode 34,数组里允许重复元素,这时候"第一个等于 target 的下标"和"最后一个等于 target 的下标"是两个不同的二分问题。你会发现在 35 题里把 lower_bound 练熟了,做 34 题会省很多力气。
来看实际的二分搜索过程。我们不要一上来就背模板,而是先明确三个问题:
- 初始边界:左边界从 0 开始,右边界是数组长度 n 还是 n-1?
- 循环条件:left < right 还是 left <= right?
- 循环结束时 left 一定指向答案吗?为什么?
这三个问题,是二分题里最容易出错的地方,网上有无数人争论"模板一"和"模板二"哪个更好。我的建议是:不追求哪套模板更万能,而是要确定一套你真正理解每一步为什么的模板。下面我详细拆解最常用的"左闭右闭"写法。
4. 左闭右闭模板:为什么最终答案是 left
所谓左闭右闭,指的是我们维护的候选区间是 [left, right],左右两个端点都可能是答案。初始化时,left = 0,right = len(nums) - 1。
每次取中间位置 mid = left + (right - left) // 2,然后看 nums[mid] 和 target 的关系:
- 如果 nums[mid] < target:说明 mid 位置以及它左边的所有元素都小于 target,它们不可能成为"第一个大于等于 target"的位置,所以 left = mid + 1,把区间收缩到右边一半。
- 如果 nums[mid] >= target:说明 mid 位置可能成为答案,也可能答案在更左边(注意,因为我们找的是"第一个"),所以不能简单地把 left 挪过来,而是要把 right = mid - 1,把候选区间收缩到左边一半,同时保留 mid 这个候选。
这里最容易犯的错误,就是在 nums[mid] >= target 时直接返回 mid。在普通二分查找里这样做是对的,因为"找到 target"就行;但本题要的是"第一个大于等于 target 的位置",如果数组是 [1, 3, 5, 6],target = 5,mid 正好指到 5 返回 2,没问题;可如果是 [1, 3, 5, 5, 6],target = 5(虽然本题无重复,但举例说明更清晰),mid 第一次可能指到 3 位置的 5,直接返回 3,那就错了,答案应该是 2。所以哪怕本题没有重复元素,我们也必须按照"找第一个"的思路来写,养成习惯。
当循环结束时,left > right,此时 left 就是答案。为什么?
我们可以这样证明:整个循环过程中,始终有一个不变量——[0, left - 1] 范围内的所有元素都严格小于 target,而 [right + 1, n - 1] 范围内的所有元素都大于等于 target。每次迭代,mid 要么落在左边区间,触发 left = mid + 1,把不满足条件的元素排除;要么落在右边区间,触发 right = mid - 1,把满足条件的元素纳入已知。循环结束时 left = right + 1,此时所有小于 target 的元素都被排除在 [left, n - 1] 之外,而 [left, n - 1] 的开头就是第一个大于等于 target 的位置。
用生活化的类比来说,你在一片按身高排好队的队伍里找一个身高刚过 170 的人。闭区间 [left, right] 表示"我目前还没确定答案可能在哪一段";每次看中间的人,如果中间这个身高不够,说明他和他左边的人全都不够,全部排除;如果中间这个人身高够了,那他就是候选,但左边可能还有更高的起点,所以压下右边界继续往左找。循环结束,剩下的第一个位置就是我们要的。
下面是标准的 Python 实现:
为什么 mid 要写成 left + (right - left) // 2,而不是 (left + right) // 2?这是个实现细节:当 left 和 right 都很大时,(left + right) 可能溢出整型范围(在 Python 里还好,但在 C++/Java 里会出问题),写成 left + (right - left) // 2 能避免溢出。这个细节在面试时提一句,是很加分的。
再看 C++ 版本:
这两段代码的完整逻辑是一一对应的。唯一要提醒的是,C++ 里 nums.size() 是无符号整数,如果 nums 为空,nums.size() - 1 会变成很大的正数,所以平时我刷题时会先判空或者直接处理边界。本题虽然测试数据里一般不会给空数组,但养成长度变量先赋值的习惯比较好。
5. 左闭右开写法与标准库:两种模板,一个答案
除了左闭右闭,还有一种非常常见的模板是左闭右开,即我们维护的区间是 [left, right),right 不包含在候选答案里。初始化时 left = 0,right = len(nums)。循环条件是 while left < right,因为当 left == right 时,区间为空,搜索结束。
每次迭代,mid = left + (right - left) // 2:
- 如果 nums[mid] < target:left = mid + 1,排除左边一半。
- 如果 nums[mid] >= target:right = mid,注意这里不要把 right 设成 mid - 1,因为 right 本身不参与候选,我们让 [left, right) 这个"左闭右开"区间左移,right 直接指向 mid,表示右边界收拢到了 mid。
循环结束时,left == right,这个位置就是答案。
左闭右开模板有一个明显的好处:循环结束的条件非常干净。left == right 时,区间为空,不需要再纠结 left 和 right 哪个是答案,它们相等,直接返回 left 就好。很多老手偏爱这套模板,因为它天然契合 C++ 标准库 lower_bound 的语义。
说到标准库,这里插一句题外话:在真实的工程开发里,你根本不需要手写这个二分。Python 的 bisect 模块里有现成函数,一行搞定:
C++ 里则是 std::lower_bound(nums.begin(), nums.end(), target) - nums.begin()。
那为什么刷题时还要手写?因为面试官想看的是你理不理解底层原理,而不是看你熟不熟悉标准库。但反过来,你在解释思路的时候提一句"这个问题本质上就是 lower_bound,Python 里叫 bisect_left",反而会让面试官觉得你对语言特性和算法底层都很熟悉。这就是"降维打击"了。
三种方式对比一下,方便你形成自己的选择偏好:
| 写法 | 区间定义 | 循环条件 | 收缩规则 | 返回 |
|---|---|---|---|---|
| 暴力遍历 | 无 | for i in range(n) | 遇到 >= target 即返回 | 循环结束返回 n |
| 左闭右闭 | [left, right] | left <= right | nums[mid] < target 时 left = mid + 1;否则 right = mid - 1 | left |
| 左闭右开 | [left, right) | left < right | nums[mid] < target 时 left = mid + 1;否则 right = mid | left(等于 right) |
| 标准库 bisect_left | 库函数 | 库函数 | 库函数 | 结果就是答案 |
我的个人建议是:挑选一套你闭着眼睛都能写对的模板,比如左闭右闭,然后所有类似的题都用它。不要去网上找"一套模板通吃所有二分题"的万能法,那些东西背下来容易,面试时稍微变一下就懵。真正的稳定来源于理解,而不是记忆。
还有一个小细节很容易被忽略:在左闭右开模板里,如果初始化 right = len(nums),那当 target 比 nums 中所有元素都大时,循环会一直往右收 left,最后 left == right == n,返回 n,正好是"数组末尾插入"的下标。这个边界处理是左闭右开模板相对更自然的地方,不需要额外判断。
6. 从 35 题出发:二分查找的变体地图和实战心得
35 题本身是二分查找的入门基石,但它的价值远不止"AC 一道简单题"。把这题钻透之后,你完全可以顺藤摸瓜,把一系列变体题一并拿下。
变体一:LeetCode 704 二分查找。 这道题是最朴素的二分——直接在一个有序数组中找 target,如果存在就返回下标,不存在返回 -1。做这道题会让很多人产生一个疑问:35 题和 704 题看起来一模一样,差别在哪?差别就在"不存在时的返回值"。704 要求返回 -1,所以你在写的时候必须在循环内判断 nums[mid] == target,直接返回 mid。而 35 题不要求判断相等,只要求把"第一个大于等于 target"的位置算出来。理解了这层差异,你就理解了 lower_bound 和 binary_search 这两种经典二分姿势的不同。
变体二:LeetCode 34 在排序数组中查找元素的第一个和最后一个位置。 这道题的题面上写着"非递减数组",也就是说数组里会有重复元素。要求找到 target 出现的第一个位置和最后一个位置。第一个位置,就是 lower_bound,也就是 35 题我们练的东西;最后一个位置,可以转换成"第一个大于 target 的位置 - 1",也就是 upper_bound - 1。所以 34 题本质上就是调用两次 35 题的思路:一次找第一个 >= target 的索引,一次找第一个 > target 的索引。
变体三:LeetCode 69 x 的平方根。 这道题不是在一个数组里二分,而是在一个"答案空间"里二分。x 的平方根一定落在 [0, x] 区间内,并且这个区间天然有序。我们直接二分答案,看 mid * mid 和 x 的关系,找"最后一个满足 mid * mid <= x 的位置"。这题是"在值域上二分"的经典入门题,做完它你就知道,二分搜索的对象不一定是数组中的元素,也可以是答案的取值空间。
变体四:LeetCode 875 爱吃香蕉的狒狒。 这道题也是"答案空间二分"的一个代表。狒狒要在 H 小时内吃完所有香蕉,求最小的进食速度 K。K 的范围从 1 到一堆香蕉里的最大值,我们把 K 当成二分对象,对每个 K 计算"按这个速度吃,需要多少小时",然后根据"是否能在 H 小时内吃完"来移动左右边界。
说到这里,不得不提一下热门题里的 994 腐烂的橘子。这题虽然也是 LeetCode 热门题,但它不是二分,而是 BFS 多源广度优先搜索的经典题。我在这里提它,是想说:刷题不能只盯着某一类算法猛练,二分、BFS、DFS、双指针、动态规划是不同维度的技能,35 题之外,像 994 这样的"多源 BFS"题也应该在刷题计划里占一个位置。但如果你目前在刷数组和二分专题,那优先把 704、34、35、69、875 这条线打穿,收获会非常直接。
再聊一个实战细节:很多人在面试时写二分,喜欢先背模板再往题目里套。我的经验是,面试官不介意你写哪套模板,但介意你讲不清楚"为什么这样收缩边界"。你可以在写代码的时候,同步说一句话:"我维护的不变量是:左边都小于 target,右边都大于等于 target。每次判断 mid 后,把不满足的一边排除。"就这一句话,胜过你背十个模板。
最后说两个我踩过的坑,希望能帮你避开:
-
死循环问题。 如果你的循环条件是 left < right,并且某个分支里出现了 left = mid(不是 left = mid + 1)或者 right = mid - 1,很容易出现 left 和 right 卡住不动的死循环。记住一个原则:当 mid 已经判断完毕之后,left 和 right 的更新必然要让区间至少缩小一位。这也是为什么大多数模板都写成 left = mid + 1 / right = mid - 1(闭区间)或 left = mid + 1 / right = mid(左闭右开)。
-
返回值"差一"问题。 很多人写完代码,发现答案总差 1。这时候不要盲目去调 "return left" 还是 "return right",而是回头想:我把"小于 target"和"大于等于 target"的分界线画对了吗?最好的验证方法是挑两三个边界测试用例过一遍,比如 target 小于所有元素、target 插入到数组中间、target 大于所有元素、target 正好等于某个元素。这四个 case 一过,基本不会差一。
这两个坑,几乎每个刷 35 题的人都会踩,一旦你理解了循环不变量,它们就不再是痛点,而是你检验自己代码的工具。
我觉得 35 题最值得玩味的地方就在于:它的题目描述没有直接告诉你答案是 lower_bound,而是在"有序数组 + O(log n) + 返回插入位置"的约束下,逼你自己把语义翻译过来。一旦翻译成功,你就从一个"背模板的选手"变成了"理解边界的选手"。这个转变,刷透这题就足够了。每次做二分前先在草稿纸上写下这个不变量,熟练之后,你再遇到排好序的题都会有底气。