二分查找边界条件全解析:从LeetCode 704到变体题通关指南
1. 一道"简单题"为什么能卡住一半面试者
1.1 从面试现场说起:二分查找的阴沟翻船
LeetCode 704 二分查找,在很多人的刷题清单里可能属于"打卡题"——题目本身标着 Easy,描述就一句话:给定一个升序数组和一个目标值,找到就返回下标,找不到返回 -1。
但你要是真去面试现场看一眼,就会发现这道题能在半小时的算法面里淘汰掉相当一批候选人。我见过不止一个简历上写着"熟悉常见算法与数据结构"的候选人,在白板上写二分查找时,要么把 while 循环的条件写成了 left < right 导致漏判,要么更新区间时写成 mid = left 导致死循环,要么面对"数组里有重复元素"的追问时当场卡住。
原因很简单:二分查找的逻辑主干只有三行,真正难的是它的边界条件。三行的核心逻辑谁都能背下来,但边界条件需要你真正理解"区间"这个概念,才会在不同题目里写对。704 的价值恰恰就在这里——它是最干净、最没有干扰项的二分查找入门题,把这题吃透了,后面 35、34、33、875 这些变体题才有得玩。
1.2 三个高频翻车点:区间、更新、出口
我先直接说结论,二分查找最容易写错的地方就三个,本文后面会逐一展开:
第一个是区间定义不统一。同一份代码里,一会儿把 right 当成"不存在的开区间边界",一会儿又当成"当前检查过的最后一个元素"。区间定义一混乱,while 条件和后面 left、right 的更新就全跟着乱。
第二个是更新方式太保守。很多人知道 nums[mid] != target 时要缩小区间,但到底写成 left = mid + 1、right = mid - 1,还是 left = mid、right = mid?选错了就会死循环或者丢掉有效的解。
第三个是没有想清楚循环结束条件。while (left <= right) 和 while (left < right) 不是随便选一个都能跑对的,它取决于你的区间是闭区间还是半开半闭区间。你选的循环条件必须和区间定义配套,这是整个二分查找里最核心的一环。
我个人习惯的说法是:二分查找三分在看值,七分在边界。 704 这道题,就是用来把这七分边界功夫练扎实的。
2. 循环不变量:三种区间写法的"保险绳"
2.1 什么是循环不变量:给代码一个约定
很多教程在讲二分查找时,会直接甩给你一个标准模板让你背,然后说"记住就好"。这么做不是不行,但一旦遇到变体题(比如找左边界、找右边界、在旋转数组里查),背模板的人就懵了。
真正稳妥的做法是抓住一个概念:循环不变量。意思是:在整个 while 循环执行过程中,你要让某个条件始终保持成立,所有的边界更新都以维持这个条件为唯一准则。只要不变量不被破坏,循环结束后的位置就一定是对的,代码也绝对不会死循环。
对于 704 这道题,不变量可以这样定义:目标值 target 一定落在当前搜索区间 [left, right] 内(如果它存在的话)。每一次循环我们都会根据 nums[mid] 的判断结果,缩小这个区间,同时确保 target 仍然可能在新的区间内。循环结束时,如果 target 存在,它必然已经被找到;如果不存在,区间会缩到为空,自然返回 -1。
这里有一个所有新手都会遇到的问题:怎么保证 target 一定还在新区间里?
答案是:因为我们每次比较的是 nums[mid] 和 target。如果 nums[mid] < target,那说明 mid 这个位置的值比目标值小,又因为数组是升序的,所以 mid 以及它左边所有位置的值都比 target 小,整块区间可以直接丢掉,下一步从 mid + 1 开始找。反过来,如果 nums[mid] > target,那 mid 以及它右边所有位置的值都比 target 大,下一步结束位置就是 mid - 1。这套逻辑不复杂,但写代码时一定要和区间定义匹配。
2.2 左闭右闭 [left, right]:最直觉也最容易写错
左闭右闭的写法最符合直觉:left 指向搜索范围内第一个可能的位置,right 指向最后一个可能的位置,两者都能被取到。所以初始化是:
因为 right 指向的是"真实存在的元素",所以每次缩小区间时,如果 nums[mid] > target,说明 target 在 mid 左边,而 mid 本身已经验证不是 target,所以新的右边界是 mid - 1,要把 mid 排除掉。同理,nums[mid] < target 时左边界是 mid + 1。
这里最容易出问题的地方是 while 条件。左闭右闭的区间里,left == right 时,区间里还有一个元素没有检查(比如 left = 3, right = 3,nums[3] 还没查过),所以循环条件必须是 while (left <= right),否则就会漏掉最后一次判断。
很多人在这一步栽跟头:写的明明是 left <= right 的循环,把区间理解成闭区间却用 left < right 做条件,导致数组里唯一匹配的元素恰好落在 left == right 那个位置时,直接返回 -1。
这是最经典的边界 bug,不自己亲手写一遍很难体会到。
2.3 左闭右开 [left, right):工程界最常见
左闭右开是 C++ STL 里迭代器的标准区间语义,也是很多开源代码喜欢的写法。它的定义是:left 指向搜索范围内的第一个可能位置(含),right 指向搜索范围之后的下一个位置(不含),所以初始化是:
注意,right = len(nums) 不是 len(nums) - 1。因为开区间意味着 right 位置的元素不参与检查,而数组最后一个有效下标是 len(nums) - 1,所以 right 取 len(nums) 时,实际覆盖的区间是 [0, len(nums) - 1],恰好是整个数组。
由于 right 是不包含的,循环条件要写成 while (left < right)。因为当 left == right 时,区间 [left, right) 已经没有任何元素了,搜索自然结束。
更新方式也要跟着变:当 nums[mid] > target 时,因为 mid 已经验证不是 target,且 target 在左半部分,新区间右边界应该排除 mid。但 right 本身是开区间边界,不包含任何元素,所以把 right 更新为 mid 其实就已经把 mid 排除在外了——因为新区间是 [left, mid),里面不含 mid 这个下标。 这是一开始最容易绕晕的地方,很多人会直觉性地写成 right = mid - 1,反而把 mid 左边的元素也丢掉了。
2.4 左开右开 (left, right):存在但少见
左开右开在算法题里几乎见不到,但不代表它没有意义。它的区间定义是:left 和 right 都不包含在搜索范围内,实际搜索的是 (left, right) 内部的整数下标。初始化时要写成 left = -1, right = len(nums),循环条件是 while (left + 1 < right),更新时直接用 left = mid 或 right = mid。
这种写法的好处是:所有情况下都可以无脑写 left = mid 或 right = mid,不用考虑 +1 或 -1,因为区间本身就已经把两个端点排除在外了。坏处是初始化太反直觉,而且判断结束条件时要想一下"什么时候区间才为空"。
我给新人的建议是:左闭右闭和左闭右开选一种练到肌肉记忆就行,通常足够了。左开右开可以作为理解"区间"这个概念的一个补充视角,不必作为主用写法。
3. 手推704:从伪码到正确代码的完整推导
3.1 输入、输出与前提条件
在写代码之前,先把题目的输入输出条件看清:
- 输入:一个按非递减顺序排列的整数数组
nums,以及一个目标值target。 - 输出:
target在nums中的下标;如果不存在,返回-1。 - 前提:数组有序。这很关键,二分查找的全部正确性都建立在这个前提上。如果数组无序,这个算法直接不成立。
这里有个细节值得注意:LeetCode 704 的原始描述说的是"升序排列",但在很多变体题里(比如 33 旋转数组),数组只是部分有序。理解清楚"有序"这个前提是二分查找的第一课。
3.2 为什么 mid = left + (right - left) // 2
很多初学者会写成 mid = (left + right) // 2。这在很多语言里是错的,或者至少是不安全的。
原因很简单:如果 left 和 right 都是很大的整数,left + right 可能超过当前编程语言中整数类型的最大值,产生溢出。一旦溢出,mid 变成一个负数或者错误的值,程序直接崩或者进入死循环。
正确的写法是:
这种写法在数学上和 (left + right) // 2 完全等价,但避免了加法溢出。为了把 mid 的计路径调整一下,面试时顺手写上这种写法,会是一个很加分的细节——它说明你想过极端边界。
你可能要问:Python 的整数是任意精度的,是不是就不用担心溢出了?说实话,Python 里确实不用担心。但算法题面试往往需要你用多种语言写,而且面试官可能要求你说明这个细节背后的原因。养成写 left + (right - left) // 2 的习惯,可以保证你在 C++、Java、Go 里都不会踩溢出的坑。
3.3 完整代码与运行痕迹
我给出左闭右闭的完整 Python 实现,这是最直观也最推荐新人起步的版本:
我们拿一个例子手动走一遍,例如 nums = [-1, 0, 3, 5, 9, 12],target = 9:
- 初始:
left = 0,right = 5,mid = 2,nums[2] = 3 < 9,排除左边,left = 3。 - 第二轮:
left = 3,right = 5,mid = 4,nums[4] = 9 == target,返回 4。
很奇怪吧?只用了两次比较就找到了。这就是二分查找的效率来源:每轮排除一半区间,而不是一个一个遍历。nums 长度 6,log2(6) 大约是 2.6,向上取整是 3,所以最多 3 次比较能出结果。
再看一个找不到的情况:target = 2。同样的数组:
- 初始:
mid = 2,nums[2] = 3 > 2,right = 1。 - 第二轮:
left = 0,right = 1,mid = 0,nums[0] = -1 < 2,left = 1。 - 第三轮:
left = 1,right = 1,此时left <= right仍然成立,mid = 1,nums[1] = 0 < 2,left = 2。 - 第四轮:
left = 2,right = 1,left > right,循环退出,返回 -1。
注意第三轮在 left == right 时还继续做了一次判断,这就是 <= 和 < 的区别。用 <= 才能保证当区间缩到只剩一个元素时,这个元素依然会被检查。如果你写成 <,那么 left == right 时循环直接退出,left 指向的元素就不会被看了——这就是我在前面说的"漏判"。
3.4 复杂度与最优性
704 二分查找的时间复杂度是 O(log n)。每次循环把搜索区间减半,所以循环次数是 log2(n) 量级。空间复杂度是 O(1),只用了几个额外变量,没有递归调用栈。
这个复杂度意味着什么?假设数组里有 10 亿个元素,log2(10^9) 大约等于 30。也就是说,哪怕数据量达到十亿级别,二分查找也只需要大约 30 次比较就能找到目标。而线性查找最坏需要比较 10 亿次。这就是为什么有序场景下二分查找是无脑优先的方案,没有之一。
有一点值得说明:二分查找并不是"一定最快的查找"。如果你只需要查一次,而且数据量很小,线性查找反而更简单——因为二分要求的"有序"是需要付出排序成本的,如果数组无序,排序一次也要 O(n log n),那就未必划算了。但如果是同一个有序数组要反复查询很多次,排序成本摊薄之后,二分查找就远胜线性查找。这个权衡思维在真实项目里比背任何代码模板都重要。
4. 面试官不会明说但一定会考:变体与陷阱
4.1 追问一:数组有重复元素怎么办
704 的原始题目没有提到重复元素,默认数组里最多只有一个位置等于 target。但面试官极大概率会追问:"如果数组里有重复元素,我要找第一个等于 target 的位置,你怎么改?"
这时核心思路变了:找到 target 后不能直接返回,要看看它左边还有没有 target。既然 nums[mid] == target 时,target 可能出现在 mid 左边,所以不能急着 return,而是要把右边界继续左移,继续搜索左半部分。等循环结束后,left 指向的位置就是第一个出现 target 的位置。
同理,如果要找最后一个等于 target 的位置,就把 left = mid + 1 放在 nums[mid] == target 分支里,继续向右找。这两个变体合在一起,就是 LeetCode 34 在排序数组中查找元素的第一个和最后一个位置。刷完 704 直接做 34,衔接非常自然。
4.2 追问二:把"查找"变成"插入"
另一个高频追问是:"如果 target 没找到,返回它应该被插入的位置。" 这就是 LeetCode 35 搜索插入位置。
解法非常巧妙:你不需要在找不到时额外处理,因为循环结束后的 left 就已经指向了插入位置。
为什么?回顾一下左闭右闭环路里的逻辑:当 nums[mid] < target 时,left = mid + 1,意味着"target 一定在 mid 右边";当 nums[mid] > target 时,right = mid - 1,意味着"target 一定在 mid 左边"。循环结束时 left > right,此时 left 恰好是第一个大于 target 的位置(或者说"target 应该占据的位置")。
看一下具体例子,继续用之前的 nums = [-1, 0, 3, 5, 9, 12],target = 2:
- 第三轮结束时
left = 2, right = 1。此时nums[2] = 3 > 2,所以 2 应该插入下标 2,把 3 及之后的元素往后挪。left正好等于 2,这就是插入位置。
所以 LeetCode 35 的答案只需要把 704 的 return -1 改成 return left,其他全部复用。掌握了这个细节,相当于一道题白赚了一道题。
4.3 追问三:旋转数组与"二分不一定查值"
再往深一层,面试官可能会问 LeetCode 33 搜索旋转排序数组。比如数组 [4, 5, 6, 7, 0, 1, 2],它是由一个升序数组在某个位置旋转得到的,要求在其中找 target。
这题的切入点是:数组虽然整体不是严格升序,但任意取一个 mid,左半段或右半段中必有一段是完全有序的。判断方法很简单:比较 nums[left] 和 nums[mid],如果 nums[left] <= nums[mid],说明左半段有序;否则右半段有序。然后在有序的那一段里判断 target 是否落在这个区间,决定搜索方向。
这种题的精髓在于:二分查找的本质是每次能排除一半的搜索空间,而不是一定要在全局有序的数组上做。只要你能设计出一个判断条件,把搜索空间一分为二且保证 target 只落在其中一边,二分查找就成立。旋转数组里"有序段"的判断,就是这种思路的一次典型应用。
4.4 二分查找什么时候不适用
聊完变体,反过来想想边界场景,这点在真实业务里反而更重要:
- 数据无序,且查询次数不多:直接线性查找更省事,犯不着先排序再二分。
- 数据存储在链表里:链表不支持 O(1) 随机访问,取 mid 本身要 O(n),二分的时间复杂度退化成 O(n log n),不如直接在链表上顺序遍历。
- 数据量极小(比如十个以内):线性查找和二分查找的常数差异微乎其微,但代码复杂度天差地别,选简单的。
这些判断在面试中主动说出来,会显得你不是在背题,而是真的理解算法的适用边界。这也是我在实际带人刷题时最看重的一点。
5. 从704出发:一条走过实测的刷题路线
5.1 路线图:先基础后变体再应用
704 做完之后,接下来的刷题顺序我建议按照"基础 → 变体 → 应用"这条线走:
| 题目 | 考察点 | 与704的关系 |
|---|---|---|
| 35 搜索插入位置 | 二分后的 left 指针语义 | 704 改一行 return |
| 34 第一个和最后一个位置 | 重复元素下的左右边界 | 704 的双指针变体 |
| 278 第一个错误的版本 | 找第一个满足条件的位置 | 和 704 反向匹配 |
| 33 搜索旋转排序数组 | 部分有序数组的二分 | 704 的区间判断升级 |
| 153 寻找旋转排序数组中的最小值 | 数组的最小值位置 | 704 的区间收缩思维 |
| 852 山脉数组的峰顶索引 | 比较 mid 与 mid+1 | 704 的比较策略活用 |
| 74 搜索二维矩阵 | 二维转一维的二分 | 704 的索引映射 |
| 875 爱吃香蕉的狒狒 | 在答案空间上二分 | 704 的反向应用 |
其中 875 特别值得单独说,因为它是把"二分查找"从"查数组下标"升级成"查答案"的经典案例,也是我最近在社区里看到讨论热度很高的一道题。
5.2 875 爱吃香蕉的狒狒:二分思路的进阶运用
875 的题意很直白:狒狒要在 h 小时内吃完所有香蕉,每小时只能吃一堆,且最多吃 k 根。求最小的 k。
正常人第一反应是从 k = 1 开始一只只试,这当然是暴力解法。但仔细想一下:k 的取值范围是 1 到香蕉数量最大值,而"在给定 k 下能否吃完"是一个单调函数——k 越大越容易吃完,k 越小越可能吃不完。单调性意味着什么?意味着可以在 k 的取值范围上做二分。
这就是二分查找的进阶用法:二分的对象不一定是有序数组里的某个值,可以是答案本身。你只需要设计一个 canEat(k) 判断函数,然后通过二分在答案空间中找出满足条件的最小值。整个过程和 704 的模板高度相似,只是"判断相等"变成了"判断是否可行"。
从 704 跨到 875 的过程,是很多人从"会写模板"到"会用思想"的分水岭。如果你已经刷透了 704,试着独立做一次 875,做完之后回头再看 704 的代码,会有一种通透感:原来 while 循环里的每一行都是可以迁移复用的。
5.3 检验是否真正掌握:给一段代码挑错
最后给一个自测方法。下面这段代码是网上流传很广的另一种二分查找写法,你来看看问题出在哪:
我当初带过的人里,第一次看这段代码,十个人里有六个人觉得它是对的,因为它看起来非常工整,而且是左闭右开写法。但实际上它有两个问题:
第一,mid = (left + right) // 2 在极端情况下有溢出风险,这是入门级问题。
第二,当 nums[mid] < target 时,更新的是 left = mid 而不是 left = mid + 1。表面上看只差一个 +1,可如果 nums[mid] < target 且 left = mid,那么下一轮 mid 可能还是同一个位置,区间根本没有收缩,直接死循环。举个例子:nums = [1, 2, 3],target = 3 时,left = 0, right = 3, mid = 1,nums[1] = 2 < 3,left = 1;下一轮 left = 1, right = 3, mid = 2,这轮找到了。看起来还行。但如果数组是 nums = [1, 3, 3],target = 3,第一轮 mid = 1 就找到了,也没问题。真正的问题出现在 target 不在数组里时:nums = [1, 2, 3],target = 4,第二轮 left = 2, right = 3, mid = 2,nums[2] = 3 < 4,left = 2,下一轮还是 mid = 2,无限循环。
把这段代码改对,其实就是把 left = mid 改成 left = mid + 1。但如果你不理解"区间收缩"的底层逻辑,就只能靠死记硬背,遇到一个考题变一下身就抓瞎。能一眼看出这段代码问题所在的同学,704 基本算过关了。
我个人在实际刷题里的体会是:704 这道题,青铜和新手看到的是"三行代码",王者看到的是"区间、不变量、退出条件、单调性、变体迁移"这一整套思想。刷完 704 别急着赶进度,先在草稿纸上把左闭右闭和左闭右开的两种写法各默写三遍,再尝试把 return -1 改成 return left,你会发现二分查找的很多秘密都藏在这个微小的改动里。