二分查找_LeetCode_704. 二分查找:思路、循环不变式、复杂度与复用边界

OpenHarmony开发一个App,安装到BearPi-HM Micro开发板 建议先阅读我们这篇,这里面详细介绍了,以及hap包安装的全过程。本篇是介绍如何开发一个App,然后安装到开发板上,比如hap包,无法安装等问题。 阅读详情

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] 比较,只有三种结果:

  1. target == nums[mid]:找到了,直接返回 mid。
  2. target < nums[mid]:由于右边所有元素都 >= nums[mid] > target,整个右半段(包括 mid)都不可能是答案,答案只可能在左半段。
  3. 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

轮次leftrightmidnums[mid]判断与动作
105239 > 3,排除左半,left = 3
23549相等,返回 4

示例 2:nums = [-1,0,3,5,9,12],target = 2

轮次leftrightmidnums[mid]判断与动作
105232 < 3,排除右半,right = 1
2010-12 > -1,排除左半,left = 1
311102 > 0,排除左半,left = 2
结束21——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 为什么不会死循环

每轮循环只有三种出路:

  1. target == nums[mid]:直接 return mid,循环结束。
  2. target < nums[mid]:right = mid - 1 < right(因为 mid <= right,所以 mid - 1 <= right - 1),右端点严格左移。
  3. 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线性查找最坏次数二分查找最坏次数
10104
1001007
1,0001,00010
10,00010,00014
1,000,0001,000,00020

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 次查询)往往更快,但会丢失有序信息,无法做范围查询和上下界查询。

六、哪些地方可以复用(以及复用的前提)

"复用"要分三个层级来看,条件完全不同:

  1. 代码原样复用:把这段 search 直接搬到另一道题。
  2. 模板骨架复用:保留"区间 + 循环 + 收缩"的骨架,但改判定条件和边界更新。
  3. 思想复用:把"在有序数组上二分"升级为"在单调判定空间上二分"(二分答案)。

6.1 代码原样复用的前提

必须同时满足以下条件,这段代码才能不改一行直接使用:

  1. 单调性:数据按参与比较的键非降序排列(升序)。降序也能用,但要把 target < nums[mid] 和 target > nums[mid] 两个分支对调,或者把访问顺序反过来。
  2. 随机访问:容器支持 O(1) 下标访问,例如 vector、array、string、内置数组。链表不行——定位 mid 就要 O(n),二分总复杂度会退化到 O(n),还不如直接遍历。
  3. 查询语义是"存在则返回任意一个下标":有重复元素时,本模板返回值不保证是第一个或最后一个。若题目要求"第一个/最后一个",见 6.2。
  4. 数据是静态的:构建后不频繁插入、删除。若需要在有序数组中动态插入,单次插入是 O(n),维护成本可能超过二分带来的收益;此时应考虑平衡树、有序集合等结构。
  5. 比较代价低:每次比较是 O(1)。如果元素是长字符串或大对象、比较很昂贵,要先评估比较次数带来的常数,或者先建索引/哈希。
  6. 比较关系是全序:target 与元素之间可以直接比较,且比较满足严格弱序(不会出现 a < b、b < a、a == b 同时为假以外的不一致情况)。
  7. 长度安全: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 <= rl = mid+1 / r = mid-1mid 或 -1
第一个 >= x[l, r) 半开l < rr = mid / l = mid+1l
第一个 > x[l, r) 半开l < rr = mid / l = mid+1l
第一个 == 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 就必须向上取整。

二分答案的三步:

  1. 确定答案范围 [lo, hi]:最小可能值到最大可能值。
  2. 写 check(x):判断"答案为 x 时是否可行",要求它关于 x 单调。
  3. 确定要找"第一个 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 复用前的自检清单

每次从"本题代码"迁移到"新题"时,按顺序问自己:

  1. 数据真的有序吗? 排序用的键和比较用的键是同一个吗?(结构体按字段 A 排序、却按字段 B 比较,是经典 bug。)
  2. mid 位置在本次判断后能不能排除? 能排除用 mid ± 1;不能排除(它可能是答案)用 mid。
  3. 区间是闭的还是半开的? 循环条件和它匹配吗?
  4. 答案会落在初始区间外吗? 例如 lower_bound 的答案可能是 n,所以初始 right 必须取 n。
  5. 有重复元素吗? 需要第一个、最后一个,还是任意一个?
  6. left + right 会溢出吗? 用 left + (right - left) / 2 规避。
  7. 循环一定会终止吗? 每轮区间是否严格变小?有没有 lo = mid 配下取整这种原地打转的组合?
  8. 空数组、单元素、目标在两端这些边界,代码都覆盖了吗?

七、这种二分法在什么情况下才会想到用

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 一个判断口诀

有序数组找位置,直接二分;
答案单调可验证,二分答案;
无序、动态、要方案,先想别的。


八、常见错误清单

  1. mid = (left + right) / 2 溢出。本题范围小不会触发,但换到大数组会;统一用 left + (right - left) / 2。
  2. while (left < right) 配闭区间,漏掉最后一个元素。反例:nums = [5], target = 5,直接返回 -1。
  3. 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;
    • 无限循环。
  4. left = mid 配下取整,区间长度为 2 时死循环。反例:nums = [1,2], target = 2,l=0, r=1, mid=0,nums[0] < 2,若写 left = mid,则 left 永远是 0。
  5. 返回值混淆:lower_bound 返回的是 left,不是 mid;mid 只是循环里的临时变量。
  6. 有重复元素却以为返回的是第一个。本模板只保证"返回某一个等于 target 的下标"。
  7. 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;,并提前处理空数组。
  8. 排序键与比较键不一致:按 A 排序、按 B 比较,二分的前提直接被破坏。
  9. 循环内修改数组:在二分过程中改变元素值或容器结构,导致有序性失效。
  10. 浮点二分不设终止条件:while (left <= right) 对浮点数可能永远不结束(精度极限),应固定迭代次数(如 100 次)或用 right - left > eps 且注意 eps 的选取。
  11. 把"找第一个"写成"找到就返回":提前 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 最后三句话

  1. 二分不是"背模板",而是"维护一个候选区间"。 写之前先写清楚区间是什么、空区间长什么样、每次排除哪一半,代码自然就对了。
  2. mid ± 1 和 mid 的区别,本质是"这个位置有没有被判定过"。 判定过就排除(±1),没判定、且可能是答案就保留(mid)。
  3. 最强的复用不是抄代码,而是识别"单调性"。 只要能把问题写成"猜一个 x,判断行不行,且可行性随 x 单调",二分就能从"数组查找"扩展到"答案搜索",适用范围会大一个量级。
FastAPI 高级特性:同异步路由函数、依赖注入与后台任务 在现代 Web 开发中,高效的性能和简洁的代码结构是至关重要的。FastAPI 作为一个现代、快速(高性能)的 Web 框架,凭借其对异步编程的原生支持和直观的依赖注入系统,迅速成为开发者的热门选择。在本文中,将深入探讨 `FastAPI` 中的几个核心概念:同异步函数的区别、`Depends` 依赖以及后台任务。 阅读详情

相关推荐

STRING数据库的蛋白质相互作用(PPI)网络分析

在转录调控相关的文献中,我们经常能够看到这样的蛋白质相互作用网络(protein protein interaction network,PPI network)。具体而言,这些相关的文献中首先通过RNA-seq、表达谱芯片或者蛋白质组分析等,找到了在不同分组样本间一系列的差异表达基因或蛋白。

weixin_43029125的博客 9463

《算法题讲解指南:优选算法-二分查找》--17.二分查找(附二分查找算法简介),18. 在排序数组中查找元素的第一个和最后一个位置

本文介绍了二分查找算法的核心思想及其应用。二分查找通过将有序数组区间不断减半,实现O(logN)的高效查找。文章详细解析了标准二分查找的实现流程,包括左右指针移动策略和边界条件处理。同时深入讲解了查找元素在排序数组中第一个和最后一个位置的变种问题,重点分析了查找左右边界时mid取整方式的不同(左边界向下取整,右边界向上取整)及其必要性。提供了C++代码实现和算法模板,帮助读者掌握二分查找的核心技巧和常见变种的解题思路。

2501_91275995的博客 750

C#:WPF格式转Winform格式

WPF格式转Winform格式

Hello C++ 1296

二分查找边界条件详解:从手写实现到Python bisect实战

在有序数组中高效定位目标元素,是算法工程中最基础也最常用的能力之一。二分查找凭借O(log n)的时间复杂度,成为数据处理、搜索定位、区间查询等场景的核心算法思想。然而,许多开发者面对循环条件、区间开闭和重复元素边界时容易犯错。理解左闭右闭与左闭右开的区间维护原理,掌握查找第一个、最后一个目标值等变体写法,是突破二分查找难点的关键。Python标准库中的bisect模块封装了成熟的二分查找逻辑,提供bisect_left、insort_right等函数,适合在生产环境中处理有序列表的插入与查询。结合Leet

weixin_33787529的博客 374

POVME3口袋体积计算:从.ini配置到实战解析

本文详细解析了POVME3口袋体积计算工具,从核心原理、环境准备到实战应用。重点剖析了控制计算行为的.ini配置文件,包括如何定义口袋区域、精修范围及锁定目标,并提供了固定坐标与配体引导两种实战策略,帮助研究人员从分子动力学轨迹中量化分析蛋白质结合口袋的动态变化。

weixin_29043895的博客 540

set_data_check专题[使用,report_timing,setup/hold检查]

set_data_check用于约束『数据-对-数据』的『建立保持』时间检查,通常被称为非时序约束 ( non-sequential constraints ), 理论上set_data_check 可以设在任意的两个data pin 上,其中一个pin 称为 constrained pin 类似于寄存器的data pin, 另一个pin 称为related pin 类似于寄存器的clock pin.

cy413026的博客 1万+

LeetCode 0035 搜索插入位置题解:基于二分查找的插入点定位算法详解

本文是「算法通关手册」[LeetCode 题解库](https://link.gitcode.com/i/fed89579cf94840dec9d604561d95a81) 中对 **0035. 搜索插入位置** 的完整解析。该题是二分查找在「查找插入位置」场景下的经典入门题目:给定一个已升序排列的无重复元素数组与目标值,要求在 $O(\log n)$ 时间内返回目标值的下标;若目标值不存在,则返

gitblog_00058的博客 462

攻克低照度检测难题:YOLOv11主干网络增强新方案PE-YOLO详解

编码器部分# 解码器部分self.dec_conv2 = nn.Conv2d(512, 128, 3, padding=1) # 跳跃连接self.dec_conv3 = nn.Conv2d(256, 64, 3, padding=1) # 跳跃连接self.dec_conv4 = nn.Conv2d(128, 32, 3, padding=1) # 跳跃连接# 编码路径# 解码路径(带跳跃连接)

FJN110的博客 115

LeetCode 162 寻找峰值:从暴力扫描到二分查找的经典题解(InterviewGuide 刷题笔记)

> 本文基于 InterviewGuide 仓库「精选力扣 300+ 道算法题」之[二分查找专题](https://link.gitcode.com/i/1ec08e205e9f26c162fec692774198d5)中的第 162 题刷题笔记整理扩充而成。围绕「峰值元素」这一核心概念,文章将依次给出暴力扫描与二分查找两版完整可运行的 C++ 解法,深入讲解**为什么无序数组也能用二分**、**

gitblog_00097的博客 382

[deprecated]第四章:TTM分析: 4.2.1 存储分配ttm_bo_validate功能实现分析

ttm_bo_validate是TTM框架中负责验证和调整BufferObject物理内存分配的核心函数,主要用于显存管理。该函数通过placement参数判断BO是否需要迁移或重新分配资源,完成内存分配、迁移及缓存策略调整等操作。实现流程包括资源释放、兼容性检查、迁移保护、新资源分配、迁移实现等步骤,支持多跳迁移和临时缓冲区。典型应用于显存溢出迁移、缓存策略调整、驱动初始化等场景,确保BO始终处于预期状态。

图形/计算GPU的驱动与虚拟化技术分享园地 859

软考中级-软件设计师 23种设计模式(最详细解析!!)

软考中级-软件设计师 23种设计模式

片言可决讼,半纸能缚龙 2万+

InterviewGuide 算法精讲:LeetCode 278. 第一个错误的版本——二分查找找分割点的边界处理与整数溢出陷阱

> 本文基于 InterviewGuide 仓库「精选力扣 300+ 道算法题」二分查找分栏下的 [278. 第一个错误的版本](https://link.gitcode.com/i/f29c4bd1ba5f6d252d5d218713e00c41) 笔记展开。这道题是二分查找中典型的「找分割点」问题:它不是在一个有序数组里找一个确定的值,而是在一个只有 true/false 两种状态的单调序列中

gitblog_01062的博客 97

Python调用CANoe

我们可以创建CANoe应用程序对象,打开配置文件,启动模拟,发送和接收消息,并在完成后关闭CANoe应用程序。这使得我们能够使用Python自动化执行测试任务,并集成CANoe的功能到我们的Python应用程序中。CANoe是一款功能强大的汽车网络仿真和测试工具,它能够模拟和分析汽车网络通信,并提供丰富的测试功能。通过Python编程语言,我们可以方便地调用CANoe的API,实现自动化测试和集成CANoe的功能到我们的Python应用程序中。在CANoe中,我们可以为不同的汽车网络创建配置文件。

AzqLinux的博客 1289

BepInEx 插件加载全流程拆解:从 Doorstop 注入到插件实例化,每一步怎么验证

BepInEx 是面向 Unity Mono、Unity IL2CPP 与 .NET 系游戏的插件/模组加载框架,在游戏进程执行第一行业务代码之前接管程序集加载,发现、排序并实例化 `BepInEx/plugins` 目录下的插件。本文沿"抢入口 → 拦截程序集 → 目录初始化 → 发现排序 → 实例化"五个节点拆这条插件加载链路,读完你能对一次真实启动的每个阶段指得出证据、跑得出验证命令。当前版

gitblog_00410的博客 84

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

【珍藏整理】昆仑通态位图资源一次拿全:约 1 万张 MCGS 界面素材直接导入工程

昆仑通态触摸屏位图资源仓库里只有一个核心文件:`昆仑组态位图.zip`。解压后你拿到约 1 万张 .bmp 位图资源:按钮、背景、眉头条、数值显示、流程动画,已经按 30 个风格文件夹分好类。第一次画 HMI 画面不用到处找素材,选图、导入、摆上屏,一条线走完。 | 素材类型 | 大致数量 | 适用场景 | | --- | --- | --- | | 按钮与开关(开关按钮、3D按钮、卡通按钮、分

gitblog_00858的博客 455

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

LeetCode 367:有效的完全平方数——三道 C++ 解法与二分查找的整数溢出陷阱

> 本文收录于 InterviewGuide(阿秀的学习笔记)「精选力扣 300+ 题目」之二分查找专题,对应仓库文件为 [367.有效的完全平方数.md](https://link.gitcode.com/i/d217cefdd56f749e5fe8438added00d0)。文章以原题解为核心,完整继承三种解法与溢出分析,并结合仓库中 [69. x 的平方根](https://link.git

gitblog_00899的博客 234

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Hello 算法搜尋章節練習精解:二分搜尋區間收縮、重複元素邊界與方法選型實戰

本篇技術指南以《Hello 算法》繁體中文版「搜尋」章節的練習題為核心,逐題精講二分搜尋的區間收縮過程、重複元素左右邊界的求法,以及順序查詢、二分搜尋與雜湊表三種方法的選型思路,並完整解析兩道經典的二分搜尋程式設計練習(LeetCode 704、35)。讀者完成本篇後,將能獨立推演二分搜尋的每一輪區間變化、正確實現重複元素邊界查詢,並在實際場景中做出合理的搜尋方法選擇。 本文所有練習均對應《He

gitblog_00470的博客 770

hello-algo 搜索章节练习题全解:二分查找缩区间、重复元素边界与搜索方法选型

本篇以《Hello 算法》(hello-algo)搜索章节的练习文档 [exercises.md](https://link.gitcode.com/i/e1c00c9268d2c94787f27b702047dcfd) 为主体,完整覆盖其中 3 道知识巩固题与 2 道编程题的题目、解题提示与参考答案,并结合同仓库的 Python / C++ 参考实现(如 [binary_search.py](h

gitblog_01105的博客 463

Step-Audio-R1.5 的 Step-SPQA 评测实战:550 条副语言问答如何打分?完整双轨评分指南

**Step-SPQA**(全称 StepEval-Audio-Paralinguistic Question Answering)是 Step-Audio-R1.5 开源的副语言音频问答评测集,共 **550 条问答样本**、覆盖 **11 类副语言子任务**,每条样本只需"听音频 + 答文本",官方评分采用**精确匹配 + 语义判定**的双轨方法。对新手来说,它是理解"音频模型到底能不能听懂语

gitblog_00246的博客 357

3步下载加载AMD-OLMo-1B-SFT-DPO_rai_1.9.0_m_1.0.1_npu:ModelScope SDK与Git克隆入门教程

本教程面向新手,用 **3 步** 带你完成 **AMD-OLMo-1B-SFT-DPO_rai_1.9.0_m_1.0.1_npu** 的下载与加载:这是一个基于 OLMo-1B 开源语言模型、经 SFT 监督微调与 DPO 偏好对齐后的模型,且针对 NPU 加速设备做了适配。你只需掌握 **ModelScope SDK** 或 **Git 克隆** 任意一种下载方式,即可把模型权重拉到本地并跑

gitblog_00456的博客 513

Jasna 视频修复检测模型选型:三条技术路线完整横评与避坑清单

Jasna 是一款视频马赛克修复工具:先逐帧检测出马赛克区域,再对裁出的局部画面做重建。检测这一步找得不够准,修复覆盖就不完整;跑得不够快,整条流水线会被它拖住。这篇文章基于仓库源码、官方文档与基准报告,回答一个具体问题:你的硬件和片源,分别该用哪个检测模型。 ## 一、选型速览:按场景和硬件直接给结论 | 使用场景 | 首选模型 | 备选 | 适配硬件 | 一句话理由 | | --- | -

gitblog_00047的博客 466

BinarySearch二分查找

给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。

2301_76908175的博客 359

LogicStack-LeetCode 刷穿 LeetCode:611. 有效三角形的个数(中等)——排序、二分与双指针三解法全解析

本篇技术指南围绕「刷穿 LeetCode」系列第 611 题展开,完整讲解如何在给定数组中统计能组成三角形的三元组个数,并给出从「排序 + 暴力枚举」到「排序 + 二分」再到「排序 + 双指针」的三层递进式解法,配合 Java / C++ / Python 三种语言的可运行代码与复杂度分析。读完本文,你将掌握「先排序、后枚举较大边,再用二分或双指针压缩第三边查找范围」的组合优化套路,这一思路同样适

gitblog_00060的博客 432

LeetCode:34. 在排序数组中查找元素的第一个和最后一个位置

本文介绍了在有序数组中查找目标元素首次和末次出现位置的二分查找方法。通过修改标准二分查找算法,先找到目标元素的左边界,再通过查询目标值+1的左边界来确定原目标值的右边界。文章提供了两种实现方式:基础版本和优化版本,后者通过缩小第二次二分查找的范围来提升效率。两种方法都采用闭合区间的二分查找策略,时间复杂度为O(log n)。该解法适用于需要快速定位元素在有序数组中范围的场景。

2303_80876582的博客 57

三系统安装 BrowserSkill:AI Agent 操作浏览器完整指南

BrowserSkill 把 CLI 命令转发给浏览器扩展,让 Cursor、Claude Code、Codex 等 AI Agent 直接操作你已登录的 Chrome / Edge,任务跑在独立窗口,不打扰当前标签页。适合会用终端、想给 Agent 接上真实浏览器的你。 ## 动手前先核对这三项 - 系统:macOS(Apple Silicon 或 Intel)、Linux(x64 或 AR

gitblog_00831的博客 147

ER-Save-Editor艾尔登法环存档编辑器完整指南

本文关键词:ER-Save-Editor、艾尔登法环存档编辑器、存档修改、添加物品、属性编辑 ER-Save-Editor 是一款免费开源的艾尔登法环(Elden Ring)存档编辑工具,基于 Rust 编写,提供图形界面。它可以直接读取 PC 的 `.sl2` 存档和 PlayStation 经 Save Wizard 导出的 TXT 文本存档,支持修改属性点与魂数、向背包添加武器防具、切换圣

gitblog_09763的博客 356
上一篇: 滑动窗口_LeetCode_30.串联所有单词的子串:一次 159/183 的 WA 复盘
slippin-away
博客等级 码龄1年 12粉丝 34原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址