LeetCode 704 二分查找全攻略:从区间不变式到边界模板与变体
如果让我列一份"面试看起来很简单,挂起来也很简单"的题目清单,LeetCode 704(二分查找)一定排在前三名。题目一句话就能说完:给你一个按升序排列的整数数组 nums 和一个目标值 target,找到就返回下标,找不到返回 -1。很多人在两分钟内能写出 while (left <= right) 加三分支的版本,但一旦被追问"循环条件为什么是小于等于而不是小于",或者"为什么 right = mid 会死循环",就开始卡壳了。
这篇博文就以 704 为圆心,把二分查找的区间写法、边界习惯、通用模板、经典变体和考场注意事项一次性讲透。无论你是刚接触算法的新手,还是准备面试想快速回归基础的老兵,都可以从这里拿到一套能稳定复现的解题框架。先说明下,我默认你已经知道数组下标从 0 开始,LeetCode 要求在找不到目标时返回 -1,这两点是后面所有讨论的基准。
1. 先看清楚题目的本质:这题考的不是"查找",是"区间不变式"
1.1 题目原意与输入约束
先确认题目内容。LeetCode 704 的原始描述是:给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。题目给了两个例子:nums = [-1,0,3,5,9,12],target = 9,输出 4;target = 2,输出 -1。看起来确实简单到不能再简单,但严谨地说,这题的输入约束里有几个点会影响代码写法。
第一,数组是"升序"。这给了二分查找立足的根本。如果数组无序,二分查找根本不能成立,因为你比较完 mid 之后,无法判断 target 到底应该丢弃哪半边。第二,数组长度 n 没有给上限。LeetCode 的测试数据通常会把数组顶到几十万甚至百万级别,线性扫描虽然也能过,但显然不是这道题的本意。第三,target 可能不存在,也可能数组只有一个元素,甚至数组长度为零。如果你写的二分在 n=0 时访问 nums[mid],就会直接下标越界;如果在 n=1 时 while 条件写错,又会漏掉最后一个元素的判断。
所以这题虽然标着 Easy,但边界条件足够让你把循环条件、区间定义、返回值三件事同时揉在一起考察。我说它是"简单题里最容易翻车的一道",一点都不夸张。
1.2 为什么不能用线性扫描糊弄
很多新手的第一个想法是:我写一个 for 循环,遍历一遍 nums,碰到 nums[i] == target 就返回 i,没有就返回 -1,代码又短又不容易错。这个答案的正确性没有问题,但它不是二分查找,也没有利用到"升序"这个信息。
二分查找的核心价值在于"每次排除一半"。你可以把这个过程理解成一个猜数字游戏:对方说"我心中有一个 1 到 100 的整数,你每猜一次,我告诉你大了还是小了"。聪明的人不会从 1 开始挨个猜,而是先猜 50,根据反馈把区间砍掉一半。猜数字的最优策略就是二分:50 不行就 25 或 75,最多 7 次一定猜中。
再换一个更直观的数据对比:如果数组长度是 10 亿,循环查找最坏要对比 10 亿次,而二分查找只需要约 30 次(严格来说 log2(1e9) 约等于 29.9)。这个效率差距不是优化级别的差距,而是量级上的差距。面试官看到有序数组,期待的一定是 O(log n) 的解法,而不是 O(n) 的遍历。如果你只给出线性扫描,相当于告诉考官:我知道数组有序,但我不知道如何利用这个信息。
1.3 区间不变式才是唯一的心法
在我刷题的大部分时间里,我都靠背模板应付二分。直到后来看了很多关于循环不变式的资料,才意识到问题不在模板背得不熟,而在于我从来没有想清楚"每一轮循环到底在维护什么"。
区间不变式的意思很简单:在每一轮 while 循环开始时,你要能说出来"target 如果存在,一定被我圈在哪个区间里"。在此基础上,你每轮比较 nums[mid] 和 target,然后丢掉不可能存在 target 的那半边,并保证丢掉的半边真的不可能包含 target。当区间缩小到空,target 就必然不存在,返回 -1。
用左闭右闭区间举例子。初始时 left = 0,right = n - 1,候选区间是 [left, right],包含所有元素。每轮计算 mid,比较 nums[mid]。如果 nums[mid] < target,由于数组升序,nums[mid] 以及它左边的所有元素都严格小于 target,整个 [left, mid] 都可以丢,所以 left = mid + 1。如果 nums[mid] > target,整个 [mid, right] 都可以丢,所以 right = mid - 1。如果相等,直接返回 mid。
为什么这里一定用 mid + 1 或 mid - 1,而不是 left = mid 或 right = mid?因为 mid 这一格是已经检查过的位置。既然 nums[mid] < target,mid 就不可能等于 target,留下它就是给区间注水,下一步可能死循环。这个"已检查过的元素必须排除"的认知,比背任何模板都重要。后面你看到的各种二分变体,本质上都在维护同一个区间不变式,只是候选区间从数组下标换成了答案的取值范围。
2. 从猜数字游戏到模板代码:左闭右闭与左闭右开到底差在哪
2.1 左闭右闭:最直觉的写法
先给一个最常用的左闭右闭版本。所谓左闭右闭,就是 left 和 right 都指向实际候选元素,区间 [left, right] 中的每一个下标都是可能存在的 target。代码长这样:
这个版本的几个关键点:初始 right = len(nums) - 1,因为数组最后一个元素下标是 n-1;循环条件是 left <= right,因为当 left == right 时,区间里恰好还剩一个元素,这个元素还没判断过,必须进入循环;收缩时 left = mid + 1 或 right = mid - 1,保证 mid 所在的已检查位置被排除掉。
很多人会问:为什么循环条件不是 left < right?你只需要想一个场景:数组只有一个元素,比如 nums = [5], target = 5。此时 left = 0, right = 0。如果条件是 left < right,循环一开始就不进去,直接返回 -1,答案错了。所以左闭右闭必须用 <=,除非你在循环外再补一次 nums[left] == target 的判断。
2.2 左闭右开:很多标准库采用的写法
第二种常见写法是左闭右开,区间是 [left, right),right 本身不参与候选。这种写法和 C++ 的迭代器区间、Python 的切片语义一致,所以很多人写二分时习惯 right = len(nums),循环条件 left < right,收缩时右边界直接用 right = mid。
注意看差异。初始 right 是 len(nums),不是一个有效下标,所以候选区间的右边界是"取不到"的。当 nums[mid] > target 时,因为 mid 已经被排除,而右开区间的右端点又是不包含的,我们直接把 right 缩到 mid,正好让新的候选区间变成 [left, mid)。当 nums[mid] < target 时,左边要跳过 mid,所以 left = mid + 1。当 left == right 时,整个候选区间为空,循环结束。
左闭右开写法的好处是:循环退出时 left 和 right 相等,这个值往往可以直接解释成"第一个不小于 target 的位置",和标准库里的 lower_bound 语义天然吻合。代价是如果你用 while left <= right,就很容易造成 right 无法正确收敛,甚至 mid 越界。所以它和左闭右闭不是同一种循环条件,搭配关系必须一一对应。
2.3 一张表理清三种常见写法的差异
为了不让记忆混乱,我习惯把"区间定义、循环条件、左右收缩、退出时含义"放到一张表里。这里列左闭右闭、左闭右开、全开区间三种常见写法。
| 写法规格 | 初始区间 | 循环条件 | left 收缩 | right 收缩 | 循环退出时 |
|---|---|---|---|---|---|
| 左闭右闭 | [0, n-1] | left <= right | left = mid + 1 | right = mid - 1 | left > right,区间已空 |
| 左闭右开 | [0, n) | left < right | left = mid + 1 | right = mid | left == right,区间已空 |
| 全开区间 | (-1, n) | left + 1 < right | left = mid | right = mid | left + 1 == right,两指针相邻 |
从表里可以总结出两条铁律。第一,无论什么区间写法,只要 mid 被比较过并且不是目标,就应该把它从候选区间里"丢掉",反映到代码上就是 left 要加 1,或者 right 直接指向 mid(在右开边界下,mid 不在候选区间)。第二,循环退出条件和区间为空的条件必须自洽。闭区间为空是 left > right,所以循环条件是 left <= right;半开区间为空是 left == right,所以循环条件是 left < right。把这两个组合交叉使用,是绝大多数二分边界 bug 的来源。
2.4 为什么 mid 要用 left + (right - left) // 2
这个细节几乎每次面试都会被追问。很多人的第一版代码是 int mid = (left + right) / 2,在 LeetCode 的常规测试用例里通常不会出问题,但它是一个潜在雷:如果 left 和 right 都很大,left + right 可能超过 int 类型的上限。
C++ 里 int 是有符号 32 位,最大值约 21.47 亿。假设数组长度大到 left 和 right 都在 10 亿附近,left + right 就可能超过这个上限,变成一个负数。mid 变成负数之后,访问 nums[mid] 就会越界,程序直接崩溃。这不是纯理论,而是真实出现在一些大型测试用例里的经典坑。
用 left + (right - left) / 2 代替,就不会有这个问题,因为 right - left 永远不超过数组长度,先做减法再除以 2,数值范围很小。Java 里还可以用 (left + right) >>> 1,也就是无符号右移,同样可以从根源上避免溢出。Python 的 int 是任意精度,本地不会溢出,但为了保持代码习惯一致,我也推荐统一写成 left + (right - left) // 2。面试时候能主动说出这个细节,非常加分。
3. 手撕代码最容易翻车的地方:边界条件、死循环、漏返回值
3.1 死循环到底是怎么形成的
二分查找写多了就会发现,死循环通常不是出现在"区间很大"的时候,而是出现在区间长度已经变成 1 或 2 的时候。为什么?因为此时整数除法的向下取整可能让 mid 恰好等于 left,如果你再写 left = mid,那 left 根本不会前进,区间永远不缩,循环就卡死了。
举个例子:left = 2, right = 3,mid = (2 + 3) // 2 = 2。如果 nums[2] < target 且我们执行 left = mid,新的区间仍然是 [2,3],下一轮 mid 还是 2,left 还是 2。这就死循环了。修复方式也很简单:既然 nums[2] 已经判断过,left 应该等于 mid + 1 = 3。
反过来,如果采用左闭右闭写法且错误地写成 right = mid,当 nums[mid] > target 时,新区间还是包含 mid 这个已检查位置,同样可能导致循环不结束。所以判断完 mid 之后,必须保证收缩后的区间彻底丢掉 mid。这个原则是"反死循环"的中心思想,代码里的每个加一减一都不是无意义的。
3.2 mid 取整方向:遇到 left = mid 时要向上取整
在 704 中,因为三分支里相等就直接返回,通常不会踩到取整方向的坑。但二分查找的进阶题里,经常会有"查找最后一个满足条件的元素"这种需求,它的收缩写法往往是 left = mid。这时候如果还采用向下取整,区间长度为 2 时会原地不动。
举个例子。假设我们要找最后一个满足 check(mid) 的元素,区间是 [left, right],标准模板是:
这里 mid 向上取整,就是为了避免 left = mid 时死循环。你可以验证一下:left = 2, right = 3,向上取整 mid = 3。如果 check(3) 为真,left = 3,循环结束;如果为假,right = 2,循环结束。无论如何区间都会缩小。如果这里还用向下取整,left 会一直停在 2。
所以我的建议是:不要死记"向上还是向下",而是看收缩时会不会把 left 留在原处。只要收缩分支包含 left = mid,就考虑用向上取整;如果收缩分支是 left = mid + 1,向下取整没问题。这个判断规则可以覆盖绝大多数二分变体。
3.3 多语言实现与提交通过的关键注释
二分查找的语言实现本身没什么门槛,但每个语言都有一些细微差别。我给出比较常见的四种版本,并在注释里标出容易出错的地方。
Python 版(左闭右闭):
Java 版(左闭右闭):
C++ 版(左闭右闭):
JavaScript 版(左闭右闭):
这四个版本的核心逻辑完全一样,差别只在语法。注意在 C++ 中,如果 nums 是 vector,size() 返回的是无符号类型,直接写 int right = nums.size() - 1 在空数组时会有风险。所以我通常先转成 int 再计算长度。这个细节在做 PTA 函数题时尤其重要,因为平台可能用非常规的容器类型。
说到"漏返回值",常见错误是在左闭右闭写法中把循环条件写成 left < right,然后循环外直接 return -1。这样一来,当 target 落在最后一个未被检查的下标时,你的循环根本不会判断它,直接返回 -1。正确做法有两种:要么把循环条件改成 left <= right,要么在循环外补 if (left == right && nums[left] == target) return left。很多人刷题多年还在这里反复出错,根源就是没有把循环条件和区间定义绑定在一起。
4. 从 704 延伸出的通用二分模板:lower_bound 与 upper_bound 才是高频考点
4.1 标准库里已经帮你写好了二分
在实际工程里,我几乎不自己写二分查找,因为标准库提供了足够可靠的实现。C++ 的 里有 lower_bound、upper_bound、binary_search;Python 的 bisect 模块提供了 bisect_left、bisect_right、bisect;Java 的 Arrays 类有 binarySearch;Go 有 sort.Search。这些函数经过大量测试,性能稳定,语义明确,比自己手写可靠得多。
但为什么面试官还是喜欢让你手写二分?一方面是因为标准库没法在白板上直接调用,另一方面是因为手写二分能真实反映你对边界条件的理解。如果你能同时说清楚"LeetCode 704 相当于自定义的二分查找,而 lower_bound 返回的是第一个 >= target 的位置",面试官会认为你不是只会背代码,而是真的理解查找问题的分类。
LeetCode 704 和 lower_bound 的区别在于:704 只要求返回任意一个等于 target 的下标,如果数组里没有重复元素,两者找到的位置一样;如果数组里有重复元素,704 可以返回任意一个重复下标,而 lower_bound 会固定返回第一个等于 target 的位置。理解这个差异,对后面做 LeetCode 34(查找元素在排序数组中出现的第一个和最后一个位置)会很有帮助。
4.2 手写 lower_bound 和 upper_bound 其实只有几行
lower_bound 的语义是:在有序数组 nums 中,返回第一个大于等于 target 的下标。如果所有元素都小于 target,返回 len(nums)。Python 代码:
解释一下这个写法。初始区间 [0, n) 是左闭右开,mid 向下取整。当 nums[mid] >= target 时,说明 mid 可能是答案,也可能答案在更左边,所以把右边界缩到 mid,保留 mid 不放弃。当 nums[mid] < target 时,mid 不可能是答案,把 left 移到 mid + 1。循环结束后 left == right,就是第一个满足条件的位置。
upper_bound 的语义是:返回第一个大于 target 的下标。它的写法和 lower_bound 几乎一样,只是把判断从 >= 改成 >:
如果你的题目需要"查找第一个等于 target 的位置",可以这么组合:先 lower_bound 得到 pos,再检查 pos 是否越界以及 nums[pos] == target。LeetCode 34 的解题思路就是 lower_bound 找第一个,upper_bound 找最后一个的下一个,然后左闭右开取区间。704 作为基础题,其实已经把通往这些变体的路铺好了。
4.3 两段式模板:画一条 check 线,解决边界焦虑
很多网上的二分模板会把"区间收缩"抽象成 check(mid),个人觉得这是值得理解的做法。所谓 check(mid),就是问自己一个问题:"mid 这个位置,满足题目要求吗?"如果满足,答案可能在左侧还是右侧?如果不满足,答案又可能在哪儿?想清楚之后,代码自然就出来了。
两个最常用的模板如下。
第一个找"第一个满足 check 的下标",采用左闭右开加 right 收缩:
第二个找"最后一个满足 check 的下标",采用左闭右闭加 left 收缩和向上取整:
看到一个比较完整的套路了吗?当 check(mid) 为真且需要保留 mid 时,你就让边界向 mid 靠拢(right = mid 或 left = mid);当 check(mid) 为假时,mid 一定不可用,就用 mid + 1 或 mid - 1 把它丢掉。704 的情况更特殊,因为 check 有三个结果,等于就直接返回,不需要把 mid 保留到下一轮。如果你把 704 和这两个通用模板对照着看,会发现其实是在同一个框架上做简化。
我个人的习惯是:先把"二分的是什么"说清楚,再写代码。二分的有序数组,还是二分答案的取值区间?当 target 存在时,我是要找等于、第一个大于等于、还是最后一个小于等于?这些前置问题不解决,套模板只会越套越乱。
5. 别只背代码:二分查找适用的场景和经典变体
5.1 从有序数组到二段性
很多人学完 704 以后,以为二分查找只适用于"有序数组里找一个元素"。其实这是一个很大的误解。二分查找真正需要的是"二段性",也就是在候选区间中,存在一个分界点,使得分界点一侧满足某种性质,另一侧不满足。数组本身是否全局有序,只是二段性的一种来源。
举一个经典例子:LeetCode 33 搜索旋转排序数组。数组 [4,5,6,7,0,1,2] 不是单调有序的,但它可以看成两个有序段拼在一起。你可以先通过比较 mid、left、right 的值判断当前中点落在左段还是右段,再决定下一步搜索哪半边。它依然是 O(log n) 的二分,但判断条件比 704 复杂不少。
再比如 LeetCode 162 寻找峰值,数组局部有升有降,不是有序的,但根据 nums[mid] 和 nums[mid+1] 的大小关系,可以知道峰值在左边还是右边。这同样利用了二段性。所以 704 的意义不只是教会你会用二分,更是帮你建立一个认知:只要你能证明"某一边一定可以丢弃",二分就能工作。数组有序只是最简单、最容易证明的一种情况。
5.2 二分答案:在"可行性区间"而不是数组上折半
接下来是竞赛和面试里更高级的玩法:二分答案。这种题里,数组本身可能没有直接让你搜索的目标值,你需要在一个连续的答案区间里二分,每次用 check(mid) 判断 mid 这个答案是否可行。典型的特征是问题要求"最大值最小"或"最小值最大"。
LeetCode 875 爱吃香蕉的珂珂就是一个例子。珂珂要在 h 小时内吃完所有香蕉,她需要确定每小时吃几根速度 k 最小。k 的取值范围是 [1, max 堆香蕉数],在这个范围里二分 k,每次都模拟一下"用速度 k 需要多少小时",判断能否在 h 小时内完成。如果速度 k 可以,那更大的速度一定也可以,因此存在单调性,可以二分。
再比如 LeetCode 410 分割数组的最大值,要求把数组分成 m 段,使得各段和的最大值最小。这类题往往用动态规划也能解,但二分答案加贪心 check 往往是更简洁的思路。它们和 704 的关系是:704 是直接在索引空间上二分,二分答案是在值域空间上二分,底层逻辑完全相同。能做对 704,只是拿到了二分查找的入场券。
5.3 PTA 函数题和 LeetCode 704 的关联:平台上要注意什么
最近搜索热度里有个词是"二分查找 pta 函数",说明很多人刷完 704 之后又去拼题 A(PTA)上做同类函数题。PTA 上确实有一道经典二分查找函数题,通常会给你一个已排序的顺序表 L 和关键字 X,让你实现二分查找。它和 LeetCode 704 的算法一模一样,区别主要在接口契约和返回值约定。
PTA 的函数题通常要求补全一个函数,比如 Position BinarySearch(List L, ElementType X),Position 可能从一开始计数,找不到时返回 NotFound(一般是 0)。这和 LeetCode 从 0 开始计数、找不到返回 -1 的习惯不同。如果你把 704 的代码直接搬过去,找到下标 0 的元素时会返回 0,但 PTA 会认为 0 是"未找到",结果就错了一半。
我的建议是:在平台上做题前,先花 30 秒看题目给出的类型定义、返回值和边界说明。有些老师会故意把表头设计成偏移一位,有些则不会。这个坑不是算法问题,而是工程上的接口适配问题,和真实项目里对接第三方 API 时"先对齐语义"是一样的。能意识到这一点,说明你已经不是只会写 leetcode 风格代码的新手了。
6. LeetCode 704 完整解题报告:从分析到 AC 的检查清单
6.1 复杂度与递归/迭代的选择
先看复杂度。二分查找每轮排除一半区间,所以最坏情况下执行 log2(n) 轮,每一轮只做常数次比较和赋值,时间复杂度 O(log n)。空间上只用到了几个变量,没有额外数组,也没有递归栈,空间复杂度 O(1)。
这里有个老问题:用递归实现二分查找行不行?行,但没必要。递归版本每次调用都要压栈,即使深度只有 log n,也比迭代版本多了一些函数调用开销,而且容易在返回值处理上写错。实战中我推荐迭代版本,除非面试官特意要求递归。如果要用递归,必须注意递归出口和区间更新要对齐,否则会非常难调试。
以 704 为例,用左闭右闭迭代版提交,时间和内存表现都很稳定。LeetCode 的判题环境对 O(log n) 的解法没有任何压力,真正的考验在于面对大规模数据时你写的分支是否正确、是否会越界。所以 AC 之后,我建议你手动改几个用例验证边界,而不是只看绿勾就完事。
6.2 测试用例设计:别只靠题目样例
LeetCode 的样例只会覆盖最常规的情况,真正检验你代码质量的是各种边界用例。平时我会在本地或直接提交前自己构造如下几类:
- 空数组:nums = [],任何 target 都应返回 -1。这能测试你的初始化是否安全。
- 单元素数组:nums = [5]。target = 5 应该返回 0,target = 0 或 7 应该返回 -1。这能揭穿循环条件写成 left < right 的问题。
- 目标位于数组两端的极小值和极大值。
- 目标不存在且小于所有元素;目标不存在且大于所有元素。
- 目标存在且有多个重复。704 允许返回任意一个下标,但你不能返回一个没有 target 的下标。
- 大数组压力测试:用 n 接近 1e6 的升序数组,确认 mid 计算不会溢出(本地 Python 虽不会溢出,但可以验证逻辑)。
如果你用手写递归版本,还要注意递归层数是否过大导致栈溢出。不过二分递归深度只有 log n,这个风险很小。
6.3 易错点复盘:把失败用例当朋友
我把常见错误汇总成一个表,方便你提交前自查:
| 错误现象 | 根因 | 正确做法 |
|---|---|---|
| 空数组访问越界 | right = len(nums),while (left <= right) 时直接取 mid | 空数组单独返回 -1,或用左闭右闭 right = n-1 让 right < left 直接结束 |
| 循环结束后找不到最后一个元素 | 左闭右闭却用了 left < right | 改成 left <= right,或循环外补 nums[left] 判断 |
| 死循环 | nums[mid] < target 时用 left = mid | left 要跳过已检查的 mid,即 left = mid + 1 |
| 死循环 | nums[mid] > target 时用 right = mid 且采用左闭右闭 | 采用右开写法时 right = mid 才对;闭区间要 right = mid - 1 |
| mid 计算溢出 | (left + right) / 2 | 使用 left + (right - left) / 2 或 >>> 1 |
每次刷完二分题,我都建议把这张表贴在 IDE 旁边。它比任何模板都有用,因为模板解决不了"你写错了但不知道错在哪"的问题。
6.4 一个很多教程没讲的 C++ 溢出细节
前面提到过 left + right 溢出,但还有一个更隐蔽的 C++ 细节:vector 的 size() 返回的是无符号的 size_t。如果你直接写 int right = nums.size() - 1,当 nums 为空时,nums.size() 是 0,0 - 1 在无符号整型里会变成一个很大的数,再赋给 int 时,行为取决于平台,通常变成 -1,但有符号转换语义很容易出问题。
我在做 PTA 函数题时就踩过这个坑。PTA 上给的 List 可能是静态数组加 length 字段,Length 本身是 int,所以还好;但 LeetCode 的 C++ 题解中如果直接写 int right = nums.size() - 1,虽然绝大多数编译器会得到预期的 -1,却不是一个严谨的写法。更稳妥的是先 int n = (int)nums.size(); int left = 0, right = n - 1; 这样逻辑清晰,也不依赖隐式转换。
另外,如果你在 Java 里用 int mid = (left + right) / 2,当数组长度接近 Integer.MAX_VALUE 时同样可能溢出。用 (left + right) >>> 1 是无符号右移,对正数来说结果和除以 2 一样,但不会因为溢出变成负数。这个细节能给面试官留下"这个人是真调试过大型数组"的印象。
最后再分享一个我自己的小习惯:每次做完 704,我会顺手把同一套代码改造成 lower_bound 和 upper_bound 两个版本,再拿 LeetCode 35(搜索插入位置)和 LeetCode 34(查找元素的首末位置)验证一遍。这样做的好处是,你能把"找任意一个等于"和"找边界位置"这两类二分语义真正分开,而不是把它们混在一起。等你需要处理更复杂的二分答案问题时,这个基础会让你明显少走弯路。