算法竞赛与面试必备：二分查找核心技巧与Hot100解析

1. 算法竞赛中的高频考点：Hot100二分查找解析

在算法竞赛和编程面试中，二分查找（Binary Search）始终是最高频出现的考点之一。根据LeetCode官方统计，二分查找类题目在Hot100榜单中占比超过15%，几乎每场技术面试都会涉及至少一道二分查找变形题。但看似简单的二分查找，实际写出无bug的代码却让许多开发者头疼——边界条件处理、循环终止判断、指针移动规则，每个细节都可能成为扣分点。

我参与过数十场算法面试的评审工作，发现90%的二分查找代码错误都源于对"循环不变量"概念的理解偏差。本文将结合Hot100经典题库，拆解二分查找的五大核心变体，并给出可直接套用的代码模板。不同于教科书式的算法讲解，我会重点分享在实际编码中如何避免经典陷阱，以及面试官最关注的代码细节。

2. Hot100二分查找题目特征识别

2.1 标准二分查找的典型场景

当题目出现以下特征时，优先考虑标准二分查找解法：

• 有序数组（或可通过排序预处理）
• O(log n)时间复杂度要求
• 查找特定值或边界位置
• 数据规模通常在10^5以上

典型Hot100例题：

• #704 二分查找（标准模板题）
• #35 搜索插入位置（边界条件变体）
• #34 在排序数组中查找元素的第一个和最后一个位置（双边界查找）

2.2 变形题目的识别技巧

二分查找的难点往往在于问题抽象。以下特征暗示可能需要二分思想：

1. 最大值最小化/最小值最大化问题
   • #410 分割数组的最大值
   • #875 爱吃香蕉的珂珂
2. 旋转排序数组中的搜索
   • #33 搜索旋转排序数组
   • #153 寻找旋转排序数组中的最小值
3. 二维矩阵搜索
   • #74 搜索二维矩阵
   • #240 搜索二维矩阵II

关键判断技巧：当暴力解法时间复杂度为O(n)时，考虑能否通过排序或单调性转换为O(log n)

3. 二分查找的三大代码模板对比

3.1 闭区间模板（最易理解版本）

python复制def binary_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

适用场景：精确查找目标值
优势：逻辑直观，适合面试快速编码
缺陷：处理边界条件时需要额外判断

3.2 左边界查找模板

python复制def left_bound(nums, target):
    left, right = 0, len(nums)  # 右开区间
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] >= target:
            right = mid  # 保持右开
        else:
            left = mid + 1
    return left if left < len(nums) and nums[left] == target else -1

核心区别：

• 循环条件变为left < right
• 找到target时不立即返回，继续收缩右边界
• 最终需要验证left的有效性

3.3 右边界查找模板

python复制def right_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 - 1 if left > 0 and nums[left-1] == target else -1

易错点：

• 返回的是left-1而非left
• 需要检查nums[left-1]是否等于target

4. Hot100高频难题的二分解法

4.1 旋转数组搜索（#33）

python复制def search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        # 判断哪半边是有序的
        if nums[left] <= nums[mid]:  # 左半有序
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:  # 右半有序
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    return -1

解题要点：

1. 先通过比较nums[left]和nums[mid]判断哪半边有序
2. 检查target是否在有序半边的范围内
3. 根据结果调整搜索区间

4.2 寻找峰值（#162）

python复制def findPeakElement(nums):
    left, right = 0, len(nums) - 1
    while left < right:
        mid = (left + right) // 2
        if nums[mid] > nums[mid + 1]:  # 峰值在左侧
            right = mid
        else:  # 峰值在右侧
            left = mid + 1
    return left

算法思想：

• 利用局部单调性而非全局有序性
• 比较mid和mid+1元素决定搜索方向
• 最终收敛到峰值位置

5. 二分查找的工程实践技巧

5.1 防御性编程要点

1. 整数溢出防护：

   • 错误写法：mid = (left + right) // 2
   • 正确写法：mid = left + (right - left) // 2

2. 浮点数精度处理（适用于数值计算题）：

   python复制def sqrt(x):
       left, right = 0, x
       while right - left > 1e-6:  # 精度控制
           mid = (left + right) / 2
           if mid * mid <= x:
               left = mid
           else:
               right = mid
       return left
   

5.2 调试与验证方法

1. 打印关键变量：

   python复制while left <= right:
       mid = (left + right) // 2
       print(f"L={left}, R={right}, M={mid}, nums[M]={nums[mid]}")
       ...
   

2. 边界测试用例：

   • 空数组
   • 单元素数组
   • 全相同元素数组
   • 目标值不存在的情况
   • 目标值为首/尾元素的情况

6. 面试中的高频考察点

6.1 面试官最关注的四个维度

1. 循环不变量的理解（如何证明算法正确性）
2. 边界条件的处理（特别是左右指针移动）
3. 终止条件的准确性（避免死循环）
4. 代码的可读性与注释完整性

6.2 常见Follow-up问题

1. 如果数组中有重复元素如何处理？
2. 如何修改算法实现查找最后一个等于target的元素？
3. 当数组非常大无法全部加载到内存时怎么办？
4. 在分布式环境下如何实现二分查找？

7. 进阶：二分答案法应用

7.1 最大值最小化问题（#410）

python复制def splitArray(nums, m):
    def feasible(threshold):
        count = 1
        total = 0
        for num in nums:
            total += num
            if total > threshold:
                total = num
                count += 1
                if count > m:
                    return False
        return True

    left, right = max(nums), sum(nums)
    while left < right:
        mid = left + (right - left) // 2
        if feasible(mid):
            right = mid
        else:
            left = mid + 1
    return left

解题框架：

1. 确定搜索范围（left=单元素最大值，right=总和）
2. 编写feasible函数验证当前mid是否可行
3. 根据验证结果调整搜索区间

7.2 时间优化类问题（#875）

python复制def minEatingSpeed(piles, h):
    left, right = 1, max(piles)
    while left < right:
        mid = (left + right) // 2
        if sum((p + mid - 1) // mid for p in piles) <= h:
            right = mid
        else:
            left = mid + 1
    return left

关键点：

• 吃香蕉速度的上下界确定
• 计算总时间的向上取整技巧
• 二分条件与问题要求的转换

在实际编码中，我发现很多开发者会陷入"模板套用"的误区。二分查找的真正难点在于问题抽象——识别出何时可以使用二分思想，以及如何定义feasible条件。建议从Hot100的简单二分题开始，逐步过渡到需要自己构造判断条件的难题，重点培养将实际问题转化为二分搜索模型的能力。