你真的会写二分查找吗？剖析JS算法题库中被误解最深的8道经典题

第一章：你真的理解二分查找的本质吗

二分查找，看似简单，却常被误解为“仅适用于有序数组的查找算法”。实际上，它的本质远不止于此。其核心思想是**利用决策单调性不断缩小搜索空间**，每次比较都将问题规模减半，从而实现 $O(\log n)$ 的高效求解。

二分查找的关键前提

• 搜索空间必须是有序或具有明确划分性质的区间
• 存在一个可判定的条件，能将区间划分为两部分：一部分满足条件，另一部分不满足
• 目标是找到满足条件的边界点，无论是最左、最右还是某个特定值

经典实现示例

// 在升序整数数组中查找目标值的索引
func binarySearch(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        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 // 未找到
}

适用场景对比表

场景	是否适合二分查找	说明
有序数组中找特定值	是	最典型应用
旋转有序数组找最小值	是	利用局部有序性进行判断
无序数组中找最大值	否	无法划分搜索空间

graph LR A[开始] --> B{left <= right?} B -->|否| C[返回-1] B -->|是| D[计算mid] D --> E{nums[mid] == target?} E -->|是| F[返回mid] E -->|否| G{nums[mid] < target?} G -->|是| H[left = mid+1] G -->|否| I[right = mid-1] H --> B I --> B

第二章：二分查找基础变体的深度解析

2.1 从经典实现看边界条件的微妙差异

在算法设计中，边界条件的处理往往决定了程序的健壮性。以二分查找的经典实现为例，看似简单的逻辑在不同边界设定下会产生截然不同的行为。

基础实现与边界选择

func binarySearch(arr []int, target int) int {
    left, right := 0, len(arr)-1
    for left <= right {
        mid := left + (right-left)/2
        if arr[mid] == target {
            return mid
        } else if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1
}

该实现采用闭区间 [left, right]，循环条件为 left <= right。关键在于 mid 计算使用 left + (right-left)/2 防止整数溢出，且每次移动指针时跳过已比较的 mid。

变体对比分析

• 若将区间改为左闭右开，right 初始值应为 len(arr)，循环条件变为 left < right
• 此时 arr[mid] < target 时更新 left = mid + 1，否则 right = mid
• 两种写法逻辑等价，但边界语义不同，易引发 off-by-one 错误

2.2 查找第一个等于目标值的位置：理论与调试实践

在有序数组中定位首个等于目标值的元素，是二分查找的经典变种问题。标准的二分查找仅判断是否存在目标值，而本场景需精确锁定**首次出现位置**，对边界处理提出更高要求。

算法核心逻辑

当 nums[mid] == target 时，不能立即返回，因为可能存在更早的匹配项。应继续在左半区间搜索，并记录当前有效位置。

func findFirstPosition(nums []int, target int) int {
    left, right := 0, len(nums)-1
    result := -1
    for left <= right {
        mid := left + (right-left)/2
        if nums[mid] == target {
            result = mid      // 记录当前位置
            right = mid - 1   // 继续向左查找更早的位置
        } else if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return result
}

上述代码通过维护 result 变量，在每次命中目标值时更新并尝试向左收缩搜索范围，确保最终返回的是最左侧匹配索引。

边界测试用例

• 目标值不存在：应返回 -1
• 目标值多次出现：返回最小索引
• 数组只有一个元素且等于目标值：返回 0

2.3 查找最后一个等于目标值的位置：避免死循环的关键

在二分查找中，定位最后一个等于目标值的位置需谨慎处理边界条件，否则极易陷入死循环。

关键逻辑分析

当 nums[mid] == target 时，不能立即返回，而应尝试向右收缩区间，即 left = mid + 1，以寻找更靠右的匹配位置。

func findLastPosition(nums []int, target int) int {
    left, right := 0, len(nums)-1
    index := -1
    for left <= right {
        mid := left + (right-left)/2
        if nums[mid] == target {
            index = mid      // 记录当前匹配位置
            left = mid + 1   // 继续向右查找
        } else if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return index
}

上述代码通过更新 left = mid + 1 避免了 mid 原地踏步，从而防止死循环。循环结束后，index 保存最右侧匹配位置。

常见陷阱对比

• 错误做法：使用 left = mid 可能导致区间不收缩
• 正确策略：始终确保 mid 不被重复选中

2.4 在旋转有序数组中定位最小值：思维转换的艺术

在旋转有序数组中寻找最小值，看似需要遍历整个数组，实则可通过二分查找巧妙优化。关键在于识别旋转点——最小值所在位置。

问题特征分析

旋转数组由两段递增序列构成，最小值位于右段起点。比较中点与右端点值，可判断最小值落在哪一侧。

算法实现

func findMin(nums []int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := left + (right-left)/2
        if nums[mid] > nums[right] {
            // 最小值在右半区
            left = mid + 1
        } else {
            // 最小值在左半区（包含mid）
            right = mid
        }
    }
    return nums[left]
}

该实现通过对比nums[mid]与nums[right]，动态收缩搜索区间，时间复杂度为O(log n)，优于线性查找。

2.5 寻找峰值元素：如何定义“局部最优”并收敛

在优化问题中，“峰值元素”代表数组中大于其相邻元素的点，即满足 `nums[i] > nums[i-1]` 且 `nums[i] > nums[i+1]` 的位置。这种“局部最优”虽不保证全局最大，但在梯度上升或二分搜索策略中可作为收敛目标。

峰值判定条件

对于边界情况，若首元素大于次元素，则为首峰；末元素大于倒数第二元素，则为尾峰。

二分查找实现峰值搜索

func findPeakElement(nums []int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := (left + right) / 2
        if nums[mid] > nums[mid+1] {
            right = mid // 峰值在左侧
        } else {
            left = mid + 1 // 峰值在右侧
        }
    }
    return left
}

该算法通过比较中点与右邻元素决定搜索方向，时间复杂度为 O(log n)，确保快速收敛至任一局部峰值。

第三章：二分思想在实际问题中的迁移应用

3.1 在单调函数中求解满足条件的最左值：以开根号为例

在数值计算中，许多数学函数具有单调性，这为二分查找的应用提供了基础。以平方根函数为例，对于非负实数 $ x $，函数 $ f(y) = y^2 $ 在 $ y \geq 0 $ 上单调递增。因此，求解 $ \sqrt{x} $ 可转化为在区间 $[0, x]$ 中寻找满足 $ y^2 \leq x $ 的最大 $ y $，即最左满足条件的边界值。

算法思路

使用二分查找逼近精度，设定误差阈值 $ \epsilon $，不断缩小区间直至收敛。

func mySqrt(x float64) float64 {
    if x == 0 {
        return 0
    }
    left, right := 0.0, x
    if x < 1 {
        right = 1 // 处理小于1的情况
    }
    for right-left > 1e-7 {
        mid := (left + right) / 2
        if mid*mid <= x {
            left = mid // 向右扩展
        } else {
            right = mid // 向左收缩
        }
    }
    return left
}

上述代码通过维护区间 $[left, right]$，每次判断中点平方与目标值关系，逐步逼近最左满足 $ y^2 \leq x $ 的解。初始边界处理确保了 $ x < 1 $ 时仍能正确收敛。

3.2 分割数组的最大值最小化：二分答案的经典范式

在处理“分割数组使最大值最小”类问题时，二分答案是一种高效且通用的策略。其核心思想是：枚举可能的最大子数组和，通过贪心验证该值是否可行。

算法思路

• 答案下界为数组最大值，上界为数组总和；
• 对答案进行二分，每次判断能否将数组划分为若干子数组，使得每个子数组和不超过当前中点值；
• 使用贪心法验证：尽可能多地填充每个子数组而不超限。

代码实现

func splitArray(nums []int, k int) int {
    left, right := 0, 0
    for _, v := range nums {
        if v > left { left = v }
        right += v
    }

    for left < right {
        mid := (left + right) / 2
        if canSplit(nums, k, mid) {
            right = mid
        } else {
            left = mid + 1
        }
    }
    return left
}

func canSplit(nums []int, k int, maxSum int) bool {
    count, current := 1, 0
    for _, v := range nums {
        if current+v <= maxSum {
            current += v
        } else {
            count++
            current = v
        }
    }
    return count <= k
}

上述代码中，splitArray 函数通过二分查找确定最小化的最大子数组和。每次调用 canSplit 验证在限定子数组和的情况下，能否划分出不超过 k 段。时间复杂度为 O(n log(sum))。

3.3 如何验证候选解的可行性：配合二分的check函数设计

在二分答案类问题中，check 函数是判断候选解是否可行的核心逻辑。它接收一个由二分过程传入的“猜测值”，并验证该值是否满足题目约束。

check函数的基本结构

bool check(int mid) {
    long long total = 0;
    for (int i = 0; i < n; i++) {
        total += (arr[i] + mid - 1) / mid; // 向上取整除法
    }
    return total <= m; // 是否能在m次内完成
}

该函数计算在每批处理不超过mid单位时所需的总批次数，若不超过限制m，则mid可行。

设计要点归纳

• 输入参数通常为二分的中点值（如时间、容量、长度）
• 内部逻辑需模拟实际决策过程，统计资源消耗或结果达成情况
• 返回布尔值，指导二分搜索方向

第四章：高频易错题精讲与避坑指南

4.1 搜索插入位置：为什么你的mid计算导致溢出？

在实现二分查找时，计算中间索引 `mid` 是关键步骤。常见的写法是：

int mid = (left + right) / 2;

看似合理，但在 `left` 和 `right` 接近整型上限时，left + right 可能超出 int 范围，导致整数溢出，结果为负数，引发数组越界。 正确的做法是避免直接相加：

int mid = left + (right - left) / 2;

此公式等价于原意，但规避了溢出风险，因为 right - left 始终为非负且小于等于数组长度。

为何现代语言仍需关注此问题？

即便Java、Go等语言对数组访问有边界检查，溢出仍会导致逻辑错误。例如，在搜索插入位置场景中，错误的 mid 会跳过正确区间，返回错误索引。 使用位运算可进一步优化性能：

int mid = (left + right) >>> 1;

该方式利用无符号右移，但前提是确保数值非负。综合安全与可读性，推荐使用 left + (right - left)/2。

4.2 在重复元素中查找边界：常见的逻辑漏洞分析

在处理有序数组中的重复元素时，二分查找的边界判定极易因条件疏漏导致死循环或错误结果。

典型错误模式

开发者常忽略等值情况下的区间收缩方向，导致左边界查找误用右移逻辑：

for left < right {
    mid := left + (right-left)/2
    if nums[mid] >= target {
        right = mid
    } else {
        left = mid + 1
    }
}

上述代码在查找左边界时正确，但若将 mid 赋值给 left 而未加偏移，会陷入死循环。

边界控制对比表

目标	等值操作	风险点
左边界	right = mid	left = mid 导致停滞
右边界	left = mid + 1	未+1引发无限循环

4.3 循环终止条件的选择：left < right 还是 left <= right？

在二分查找算法中，循环终止条件的选择直接影响边界处理的正确性。使用 left < right 还是 left <= right 取决于搜索空间的定义方式。

两种常见场景

• left <= right：适用于目标值精确匹配，搜索空间为闭区间 [left, right]
• left < right：常用于寻找插入位置或边界索引，搜索空间为左闭右开 [left, right)

for left <= right {
    mid := left + (right-left)/2
    if nums[mid] == target {
        return mid
    } else if nums[mid] < target {
        left = mid + 1
    } else {
        right = mid - 1
    }
}

上述代码中，left <= right 确保所有元素都被检查，mid 可能等于 right。当 left > right 时循环终止，表示搜索失败。而若使用 left < right，则需额外判断最终位置是否为目标值。

4.4 浮点数二分：精度控制与迭代次数的权衡

在浮点数二分查找中，精度要求与迭代次数之间存在显著的权衡关系。若设定过高的精度（如 1e-9），可能导致循环次数过多，影响性能；而精度太低则无法满足计算需求。

终止条件的选择

常见的做法是使用固定迭代次数代替误差判断，避免浮点精度问题导致死循环：

double low = 0, high = 1e9;
for (int i = 0; i < 100; ++i) {
    double mid = (low + high) / 2;
    if (f(mid) > 0) {
        high = mid;
    } else {
        low = mid;
    }
}

该代码通过100次迭代确保精度达到约 1e-30 量级，逻辑稳定且无需处理浮点比较误差。

精度与性能对比

迭代次数	相对精度	适用场景
50	1e-15	一般科学计算
100	1e-30	高精度需求

第五章：结语——掌握二分，不止于模板

理解边界条件的本质

在实际工程中，二分查找常用于大规模有序数据的快速定位。例如，在日志系统中查找指定时间戳的记录时，需精确处理左闭右开区间：

func lowerBound(arr []int, target int) int {
    left, right := 0, len(arr)
    for left < right {
        mid := left + (right-left)/2
        if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left // 返回首个不小于 target 的位置
}

应对复杂判定逻辑

二分不仅限于数值查找。在 LeetCode 875 题“爱吃香蕉的珂珂”中，需对“最小速度能否在 H 小时内吃完”进行二分枚举。此时，判定函数成为核心：

• 速度过小 → 吃不完 → 需增大
• 速度足够 → 能吃完 → 尝试减小
• 搜索目标：满足条件的最小值

性能对比与适用场景

算法	平均时间复杂度	典型应用场景
线性查找	O(n)	小规模或无序数据
二分查找	O(log n)	有序静态数据集
哈希查找	O(1)	频繁等值查询

流程示意： [有序数组] → 计算 mid 索引 → 比较 target 与 arr[mid] → 缩小搜索区间 → 直至区间为空