数组算法实战：二分查找、双指针与经典问题解析

1. 算法训练营开营：经典数组问题实战

作为一名经历过多次算法面试的老兵，我深知数组类题目在技术面试中的高频出现率。今天要分享的这三个题目——二分查找、移除元素和有序数组的平方，看似基础却暗藏玄机。它们分别对应着数组操作的三个核心场景：查找、修改和转换。这些题目来自知名的"代码随想录"算法训练营第一天的内容，也是大多数算法学习者的必经之路。

在实际面试中，微软、谷歌等大厂的初级算法面试题有超过60%都涉及数组操作。这三个题目特别适合用来建立对数组的基本操作直觉，尤其是对循环不变量和双指针等核心概念的理解。接下来我将从实战角度，分享如何系统性地解决这些问题，并给出一些教科书上不会提到的优化技巧。

2. 704. 二分查找深度解析

2.1 问题理解与边界分析

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，我们需要写一个函数搜索 nums 中的 target，如果存在返回下标，否则返回 -1。这个看似简单的问题，却让很多初学者在边界条件上栽跟头。

关键点在于理解循环不变量的概念——在每次循环中保持不变的属性。对于二分查找，我们需要明确搜索区间是左闭右闭 [left, right] 还是左闭右开 [left, right)。我强烈建议初学者统一使用左闭右闭区间，因为这样更符合直觉，也更容易处理边界条件。

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

2.2 常见错误与调试技巧

新手最容易犯的错误包括：

1. 循环条件写成 left < right 导致漏判边界情况
2. 更新 right 时写成 right = mid 造成死循环
3. 使用 (left + right) // 2 计算 mid 可能导致整数溢出

调试技巧：在纸上画出每次循环的 left、right 和 mid 位置，特别关注当 target 不存在时循环的终止条件。可以尝试用 nums = [5], target = 5 和 nums = [5], target = 2 这两个极端用例测试。

2.3 时间复杂度优化

标准的二分查找时间复杂度是 O(log n)，但我们可以通过一些预处理来优化实际运行时间：

1. 先检查首尾元素，如果 target 小于首元素或大于末元素直接返回 -1
2. 对于某些特定分布的数据（如均匀分布），可以使用插值查找代替纯二分

3. 27. 移除元素的双指针解法

3.1 问题重述与暴力解法

题目要求原地移除数组中所有等于 val 的元素，返回新数组的长度。不能使用额外的数组空间，必须使用 O(1) 的额外空间并原地修改输入数组。

暴力解法的思路是发现 val 时就将其后的所有元素前移一位，时间复杂度为 O(n²)。这在 LeetCode 上会导致超时，显然不是最优解。

3.2 快慢指针的精妙之处

双指针法（快慢指针）可以将时间复杂度降到 O(n)。快指针用于遍历数组，慢指针指向下一个非 val 元素应该存放的位置：

python复制def removeElement(nums, val):
    slow = 0
    for fast in range(len(nums)):
        if nums[fast] != val:
            nums[slow] = nums[fast]
            slow += 1
    return slow

3.3 变种问题处理

当要移除的元素很少时（比如 nums = [1,2,3,4,5], val = 5），可以采用首尾指针法来减少赋值操作次数。当 nums[head] == val 时，将其与 nums[tail] 交换，然后 tail--。这种方法在最坏情况下时间复杂度仍为 O(n)，但平均情况下赋值操作更少。

4. 977. 有序数组的平方的多种解法

4.1 直观解法及其局限

最直观的方法是先平方再排序，时间复杂度为 O(n log n)。这在面试中不会被认可为最优解，因为它没有利用输入数组已排序的特性。

4.2 双指针的逆向思维

由于数组已排序，最大的平方值一定出现在两端。我们可以使用头尾指针从外向内遍历，将较大的平方值逆序放入结果数组：

python复制def sortedSquares(nums):
    n = len(nums)
    result = [0] * n
    left, right = 0, n - 1
    for i in range(n - 1, -1, -1):
        if abs(nums[left]) > abs(nums[right]):
            result[i] = nums[left] ** 2
            left += 1
        else:
            result[i] = nums[right] ** 2
            right -= 1
    return result

4.3 性能对比与适用场景

在不同场景下选择合适的方法：

1. 当数组元素全为正数时，直接平方就是有序的，时间复杂度 O(n)
2. 当数组元素全为负数时，平方后是逆序的，可以先平方再反转，时间复杂度 O(n)
3. 混合情况必须使用双指针法，时间复杂度 O(n)

5. 算法训练中的常见误区与突破技巧

5.1 如何避免"一看就会，一写就废"

很多学习者看题解时觉得简单，自己写却漏洞百出。建议：

1. 严格按照"理解题意→画图分析→写伪代码→代码实现→测试用例"的流程
2. 对于每个题目至少手写实现3遍，间隔时间逐渐拉长
3. 建立自己的错误案例库，记录典型错误

5.2 调试与验证方法论

有效的调试策略包括：

1. 使用小规模测试用例（空数组、单元素数组等）
2. 在关键位置打印变量值（如二分查找中的 left/right/mid）
3. 使用断言检查循环不变量是否保持

5.3 从这三个题目中学到的通用模式

这三个题目虽然表面不同，但都体现了重要的算法思想：

1. 二分查找：分治思想的典型应用
2. 移除元素：原地修改数组的双指针技术
3. 有序数组平方：逆向思维处理有序数据

掌握这些模式后，可以解决一大类数组相关问题。例如，删除排序数组中的重复项、移动零等问题都可以用类似的双指针技术解决。

6. 进阶挑战与扩展思考

6.1 二分查找的变种问题

掌握了标准二分查找后，可以尝试以下变种：

1. 查找第一个/最后一个等于目标值的位置
2. 查找第一个大于等于目标值的位置
3. 在旋转排序数组中查找

这些变种都需要修改循环条件和更新规则，但核心思想不变。

6.2 双指针技术的其他应用

双指针不仅用于数组，还可以解决：

1. 链表中环的检测（快慢指针）
2. 两数之和（排序后使用首尾指针）
3. 合并两个有序数组

6.3 如何设计测试用例

全面的测试用例应该包括：

1. 常规情况（多个元素，目标存在/不存在）
2. 边界情况（空数组、单元素数组）
3. 极端情况（所有元素相同、超大数组）
4. 特殊值（负数、零、最大值）

例如对于二分查找，好的测试用例组合可能是：

• []（空数组）
• [1], target=1
• [1,3,5], target=2
• [1]*10000, target=1

7. 个人实战心得

在实际刷题过程中，我发现记录"解题日志"特别有用。每次解题时记录：

1. 第一思路和其局限性
2. 遇到的bug和解决过程
3. 最终优化方案
4. 相关题目的链接

这种方法虽然费时，但长期来看能形成自己的算法知识网络。例如，这三个题目看似简单，但如果能深入理解并关联起来，就能掌握数组处理的三大基本操作，为后续更复杂的题目打下坚实基础。

另一个重要体会是：不要满足于AC（Accepted）。同样的题目，尝试用不同方法解决，比较它们的优劣。比如移除元素问题，除了快慢指针，还可以尝试首尾指针法，比较在不同场景下的性能差异。