LeetCode 704 二分查找全攻略:从区间不变式到边界模板与变体

二分查找LeetCode 704区间不变式
于 2026-10-29 05:01:27 修改
·本内容遵循CC 4.0 BY-SA版权协议

如果让我列一份"面试看起来很简单,挂起来也很简单"的题目清单,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。代码长这样:

PYTHON
def search(nums, target):
left, right = 0, len(nums) - 1
while left <= right:
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1

这个版本的几个关键点:初始 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。

PYTHON
def search(nums, target):
left, right = 0, len(nums)
while left < right:
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1
else:
right = mid
return -1

注意看差异。初始 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],标准模板是:

CPP
while (left < right) {
int mid = left + (right - left + 1) / 2;
if (check(mid)) {
left = mid;
} else {
right = mid - 1;
}
}

这里 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 版(左闭右闭):

PYTHON
def search(nums, target):
left, right = 0, len(nums) - 1 # 闭区间 [left, right]
while left <= right: # 闭区间非空
mid = left + (right - left) // 2
if nums[mid] == target:
return mid
elif nums[mid] < target:
left = mid + 1 # 丢掉 mid 及左侧
else:
right = mid - 1 # 丢掉 mid 及右侧
return -1

Java 版(左闭右闭):

JAVA
public int search(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
} else if (nums[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}

C++ 版(左闭右闭):

CPP
int search(vector<int>& nums, int target) {
int n = (int)nums.size();
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;
}

JavaScript 版(左闭右闭):

JS
var search = function(nums, target) {
let left = 0, right = nums.length - 1;
while (left <= right) {
const mid = left + ((right - left) >> 1);
if (nums[mid] === target) return mid;
if (nums[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
};

这四个版本的核心逻辑完全一样,差别只在语法。注意在 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 代码:

PYTHON
def lower_bound(nums, target):
left, right = 0, len(nums) # [left, right)
while left < right:
mid = left + (right - left) // 2
if nums[mid] >= target:
right = mid # mid 可能是答案,不能丢
else:
left = mid + 1 # mid 一定不是答案
return left

解释一下这个写法。初始区间 [0, n) 是左闭右开,mid 向下取整。当 nums[mid] >= target 时,说明 mid 可能是答案,也可能答案在更左边,所以把右边界缩到 mid,保留 mid 不放弃。当 nums[mid] < target 时,mid 不可能是答案,把 left 移到 mid + 1。循环结束后 left == right,就是第一个满足条件的位置。

upper_bound 的语义是:返回第一个大于 target 的下标。它的写法和 lower_bound 几乎一样,只是把判断从 >= 改成 >:

PYTHON
def upper_bound(nums, target):
left, right = 0, len(nums)
while left < right:
mid = left + (right - left) // 2
if nums[mid] <= target:
left = mid + 1
else:
right = mid
return left

如果你的题目需要"查找第一个等于 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 收缩:

CPP
while (left < right) {
int mid = left + (right - left) / 2;
if (check(mid)) {
right = mid;
} else {
left = mid + 1;
}
}

第二个找"最后一个满足 check 的下标",采用左闭右闭加 left 收缩和向上取整:

CPP
while (left < right) {
int mid = left + (right - left + 1) / 2;
if (check(mid)) {
left = mid;
} else {
right = mid - 1;
}
}

看到一个比较完整的套路了吗?当 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(查找元素的首末位置)验证一遍。这样做的好处是,你能把"找任意一个等于"和"找边界位置"这两类二分语义真正分开,而不是把它们混在一起。等你需要处理更复杂的二分答案问题时,这个基础会让你明显少走弯路。

基于Python+Open CV的手势识别算法设计
伴随着人工智能时代的到来,人机交互的领域也逐渐成为研究的一大方向;其中,手势识别是人机交互领域的一项关键技术,自此手势识别也迎来了一波高潮,近几年无论是在消费领域、电子领域、数码领域、家电领域甚至汽车领域上,都能或多或少的见到手势识别的身影。 手势识别在设计智能高效的人机界面方面具有至关重要的作用, 目前手势识别已应用到手语识别、智能监控、到虚拟现实等各个领域,手势识别的原理都是利用各种传感器(例如红外、摄像头等)对手部的形态进行捕捉并进行建模,形成一个模型信息的序列帧,而后将这些信息序列转换为机器能够识别的相对应指令(例如打开、切换菜单、移动等)来完成控制。 采用Python的集成开发环境Pycharm进行本次课程设计,在Pycharm中进行需要库(模块)的下载,调取电脑摄像头,按帧读取摄像头采集到的头像,形态学处理,图像旋转(由于摄像头采集到的图像是镜像,需要用cv2.flip将摄像头采集到的图像进行处理),选取图片中固定位置作为手势输入,用红线画出手势识别框,基于hsv的肤色检测,进行高斯滤波,找出轮廓,求出图像中手势的凹凸点,手指间角度求取。
努力学习前端的小陈
ArcGIS Pro入门制图教程
地理信息系统 (GIS) 是一种使用地图显示和分析数据的方式。在本教程中,您将学习桌面 GIS 应用程序 ArcGIS Pro 的基础知识。新加坡的一家旅行社希望制作一款宣传册,用于向游客介绍距离市中心热门目的地最近的火车站。该宣传册将与带有文本信息的地图相结合,并在城市的自助设备中出售。您将帮助该旅行社绘制旅游景点的地图,分析其与火车站的距离以及更改地图的外观以使其在视觉上更具吸引力。在 ArcGIS Pro 中,地图和数据通常被组织在一个工程中。开始制作地图之前,您将创建一个工程。
科研online
ArcGIS Pro 布局创建与地图加载全流程解析
本文详细解析了ArcGIS Pro中布局创建与地图加载的全流程。针对从ArcMap转来的用户,重点阐述了布局与地图解耦的核心设计理念,并提供了从新建布局、设置参考比例尺、加载地图框到深度控制与精细化排版的实用技巧,帮助用户高效制作专业地图。
您的账号已被封禁
ArcGIS PRO布局视图避坑指南:地图框添加与专题图制作的5个关键步骤
本文针对ArcGIS PRO用户在布局视图中制作专题图时遇到的常见问题,提供了地图框添加与专题图制作的5个关键步骤避坑指南。从理解布局视图思维、数据框预处理、地图元素协同配置,到深化视觉层次与最终输出检查,系统讲解了如何高效产出严谨美观的专业地图,帮助用户跨越从数据分析到地图输出的最后一公里。
冰炭不同炉
ROS-CV-ImageConverter:将ROS图像转换为OpenCV(cv :: Mat)类型的图像
ROS-CV图像转换器 依存关系 cv_bridge(ROS软件包)
Willis Wang
计算机视觉图像处理-CV2与图像插值算法
用最近邻插值与双线性插值原理完成图像缩放 最近邻插值,是指将目标图像中的点,对应到源图像中后,找到最相邻的整数点,作为插值后的输。缺点:使用最近邻插值算法处理图像放大时,在图象中可能出现明显的块状效应 双线性插值,在两个方向上做三次线性插值。使用双线性插值算法处理图像放大时,在图象中可能出现马赛克 代码 import cv2 img = cv2.imread(’./xiabang.jpg’, cv2.IMREAD_UNCHANGED) #缩放比例 scale_percent = 0.3 width = int(img.shape[1] * scale_percent) height = int
weixin_38697274
基于水平集CV模型的图像分割(Matlab代码)
基于水平集CV模型的图像分割(Matlab代码),全套代码
小宇QAQ
导向滤波(guide_filter)的python实现
导向滤波(guide_filter)的python实现,可以结合暗通道;理论实现比较好的图像去噪效果。
zachzhan_g
ArcGIS Pro 如何新建布局
你是否已经习惯了在ArcGIS中数据视图和布局视图之间来回切换,到了ArcGIS Pro中却找不到二者之间切换的按钮,即使新建布局后却发现地图怎么却是一片空白。从上面的图中可以看到,虽然新建了布局,但是地图还是空白的,如果想要显示地图还需要加载一下,将地图加载进来。在新建的布局上绘制一个框,作为地图显示的范围,绘制后可以看到地图已经完成加载,如下图所示。在菜单栏上选择插入,点击新建布局下拉箭头,选择一个合适的尺寸,如下图所示。点击后完成布局的新建,新建的布局如下图所示。
水经注GIS
ArcGIS Pro数据修复与图层管理实战指南
本文是ArcGIS Pro数据修复与图层管理的实战指南。针对数据源丢失导致的“红色叹号”问题,详细讲解了一键批量修复和进阶手动修复策略,并分享了使用相对路径、打包工程等防患于未然的黄金法则。同时,深入介绍了如何利用图层组进行高效的地图内容组织、比例尺控制与批量操作,帮助用户构建清晰、智能的专业地图,大幅提升GIS项目管理效率。
Tomato
ArcGIS Pro布局设计实战:从空白页面到专业地图输出的完整工作流
本文详细解析了ArcGIS Pro中从“新建布局”开始,到输出专业地图的完整工作流。内容涵盖布局哲学、地图框深度运用、制图元素集成及视觉排版等核心环节,旨在帮助中级用户掌握项目驱动的现代化制图方法,实现从数据到出版级地图的精准转化。
AnjneyMidha
ArcGIS PRO布局视图避坑指南:地图框添加与坐标系设置的5个常见错误
本文针对ArcGIS PRO用户在布局视图中常遇的难题,重点解析了地图框添加与坐标系设置的5个常见错误。从地图框的创建逻辑、坐标系冲突的根源剖析,到地图范围控制、元素联动更新以及打印导出设置,提供了一套完整的避坑指南与实战解决方案,帮助用户高效、精准地完成地图制图与输出工作。
重离子猫猫
ArcGIS Pro布局设计避坑指南:为什么你的地图总是显示空白?
本文深入解析ArcGIS Pro布局设计中地图显示空白的常见问题,提供从基础操作到高级排错的完整解决方案。重点讲解地图框的正确使用方法、布局元素配置技巧,以及多地图框协同工作等进阶功能,帮助用户快速掌握专业地图制作的核心技术。
习翔宇
CV算法(MATLAB)
chan 和 vese 提出的经典CV模型
beastLOVE
GrabCut:使用opencv-python cv2.grabCut交互式剪切图像
GrabCut 使用opencv-python cv2.grabCut交互式剪切图像
Aaron Gary
Opencv-Python图像透视变换cv2.warpPerspective的示例
今天小编就为大家分享一篇关于Opencv-Python图像透视变换cv2.warpPerspective的示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
weixin_38711369
leetcodecv-Kylin:CV算法岗面经&LeetCode刷题总结
leetcode cv Kylin CV算法岗面经 & LeetCode刷题总结 不断更新中。。。。 面试&笔试经验 LeetCode
weixin_38499553
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS.pdf
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS真的很不错,
weixin_43905342
ArcGIS布局视图方向调整与优化技巧
地图布局方向是GIS制图的基础设置,直接影响空间数据的可视化效果。横向(Landscape)和竖向(Portrait)布局通过调整页面长宽比例,可优化不同地理要素的展示方式。在ArcGIS等专业制图软件中,方向设置会联动影响比例尺、图例等核心元素的自动适配逻辑。本文以A4纸张为例,详解通过页面设置、Python脚本批处理等技术手段实现布局方向的高效调整,并针对比例尺失准、图例溢出等典型问题提供工程解决方案。特别适用于带状区域地图制作等需要最大化利用版面空间的场景,可提升40%以上的图面利用率。
塞音菩光
ArcGIS Pro 3.4必学新功能:符号系统与布局视图的可见性联动(含省时技巧)
ArcGIS Pro 3.4引入了符号系统与布局视图的可见性联动功能,通过唯一值符号化和复选框控制,实现原子级要素显示/隐藏。这一创新极大提升了制图效率,支持在符号系统窗格、内容窗格和布局视图中同步操作,特别适合城市规划、环境监测等需要动态展示的场景。
t8u9v0
ArcGIS Pro 布局创建与地图加载全攻略
本文详细解析了ArcGIS Pro中布局与地图分离的设计哲学,并提供了从新建布局到加载地图的完整操作指南。重点介绍了如何通过“插入”选项卡新建布局、选择合适的页面尺寸,以及使用地图框工具将项目中的地图动态链接至布局。文章还涵盖了地图范围控制、比例尺锁定、图例添加等深度定制技巧,帮助用户高效创建专业地图并导出为高质量成果。
milk8
ArcGIS多图布局实战:从数据框管理到批量导出的完整指南
在地理信息系统(GIS)制图领域,将多张地图高效整合到单一版面是提升分析报告专业性与表现力的关键技术。其核心原理在于理解并运用数据框与布局视图的分离机制,通过独立的数据框承载不同区域或专题的地理数据,并在统一的布局视图中进行精确排版与视觉整合。这项技术的核心价值在于实现了制图流程的标准化与自动化,避免了传统拼图方式带来的效率低下与更新困难问题,尤其适用于区域对比、时间序列分析、综合评估报告等需要多视角、多维度展示地理信息的应用场景。本文聚焦于ArcGIS Pro平台,深入剖析了多图布局中数据框范围联动、地图
aaa1231722
monolithic-cv:CV算法的集合
单片-cv 计算机视觉算法转储
晨曦姜
改进的cv图像分割
改进的cv图像分割,对学习cv模型有帮助
a904235765
C++实现基于暗通道与导向滤波的图像去雾算法
资源下载链接为: https://pan.quark.cn/s/1bfadf00ae14 在图像处理领域,图像去雾技术用于消除大气散射导致的模糊,提升图像清晰度和视觉质量。本文将介绍一种基于暗通道和导向滤波的图像去雾算法,并探讨如何使用C++和OpenCV库实现。 暗通道理论由Jia等人于2006年提出。他们发现自然场景中存在一些低亮度像素,通常位于无直射光区域。这些像素被称为暗通道像素,可用于估计大气散射模型中的透射率。具体方法是将图像分块,在每块中找到最暗像素值作为暗通道像素。 大气散射模型是图像去雾的基础,描述了光线在大气中传播时的散射影响。模型公式为: I(x)=T(x)×J(x)+A×(1−T(x)) 其中,T(x)是透射率,J(x)是无雾图像亮度,A是全局大气光。透射率与散射程度成反比,无雾图像亮度反映物体本身色彩。 利用暗通道先验,可以近似估计透射率。假设D(x)为暗通道像素,透射率T(x)可通过迭代公式计算: T k+1 (x)= max(D)+ϵ D(x) +(1− max(D)+ϵ D(x) )×T k (x) 其中,k是迭代次数,ϵ是小常数,用于避免除零。 估计透射率后,使用导向滤波器平滑透射率图,减少噪声和边缘失真。导向滤波是一种自适应局部滤波方法,可保持图像边缘细节,同时进行平滑处理。在图像去雾中,它根据图像梯度信息指导滤波过程,更好地恢复图像清晰度。 通过大气散射模型,可得到去雾后的图像: J out (x)= T(x) I(x)−A×(1−T(x)) +A 在C++中,可借助OpenCV库处理图像数据。首先读取输入图像,然后提取暗通道,估计透射率,应用导向滤波,最终恢复无雾图像。OpenCV提供了丰富的图像处理函数,如cv::split用于分离通道,cv::min用于找最小值,cv::filter2D用于导向滤波,cv::imwrite用于保存
KaiyuanCode
cv模型图像分割matlab源程序
cv模型 matlab 图像分割源码,逻辑清晰,注释详尽。
phoenix01
CV图像分割
从pud找到的CV图像分割代码,代码的通过较少的迭代次数就可以实现图像的分割,对学习CV分割有帮助。
a904235765
ArcGIS Pro 3.0 布局视图实战:5分钟搞定专业地图的图例、比例尺与指北针
本文详细介绍了ArcGIS Pro 3.0布局视图的实战技巧,帮助用户在5分钟内高效添加图例、比例尺与指北针,打造专业地图。通过智能图例、动态比例尺和现代化指北针设计,提升制图效率与美观度,特别适合GIS初学者和从ArcMap迁移的用户。
weixin_30652491
ArcGIS Pro界面突然消失?3种恢复方法+自定义布局技巧
本文针对ArcGIS Pro用户常见的操作界面元素突然消失问题,提供了三种核心恢复方法:通过“视图”功能区一键唤回、利用“重置窗格”命令恢复默认布局,以及通过应用程序设置进行深度恢复。文章还深入讲解了如何通过停靠、分组窗格以及自定义功能区等技巧,打造高效个性化的操作界面,帮助用户从被动解决问题转向主动优化工作环境。
nnn11
PoE 的三大国际标准:PoE、PoE+、PoE++
很多人知道 PoE 能“一根网线,既供电又传数据”,但鲜少有人能说清楚:PoE 供电到底分几种标准?差别有多大?哪些设备要用 PoE,哪些必须上 PoE+ 或 PoE++?今天,我们就来一次彻底的“拆解”,把 PoE 的三大国际标准——讲得明明白白,顺便也帮你厘清网络工程中的常见“供电疑惑”。
wljslmz