双指针算法：高效解决数组/链表问题的核心技巧

1. 为什么双指针是算法面试的必杀技？

第一次接触双指针算法时，我正被力扣上那道"删除有序数组中的重复项"折磨得焦头烂额。当时我的解法是典型的暴力法——遇到重复元素就整体前移数组，时间复杂度直接飙到O(n²)，在大型数据集上直接超时。直到看到评论区大佬用几行代码就优雅解决的方案，我才恍然大悟：原来这就是双指针的魔力。

双指针（Two Pointers）本质上是通过维护两个同步或异步移动的指针来降低算法复杂度。在数组/链表类问题中，它能将许多看似需要嵌套循环的问题优化为单次遍历。根据我的面试经验，大厂算法题中至少有30%可以通过双指针或其变种解决，特别是那些要求"原地修改"或"空间复杂度O(1)"的题目。

关键认知：双指针不是某种具体算法，而是一种通过智能指针移动来减少不必要计算的策略思想。掌握它需要理解指针移动的条件和边界。

2. 力扣26题：删除有序数组重复项的标准解法与优化

2.1 问题重述与暴力解法分析

力扣第26题要求我们在原地删除升序排列数组中的重复元素，使得每个元素只出现一次，并返回新长度。不能使用额外空间，必须原地修改输入数组。

新手常见的暴力解法是这样的：

python复制def removeDuplicates(nums):
    i = 0
    while i < len(nums) - 1:
        if nums[i] == nums[i+1]:
            nums.pop(i+1)  # 删除重复元素
        else:
            i += 1
    return len(nums)

这种解法的问题在于：

1. pop(i)操作的时间复杂度是O(n)，因为需要移动后续所有元素
2. 最坏情况下（全部重复）时间复杂度达到O(n²)
3. 频繁修改数组长度影响可读性和性能

2.2 双指针的标准实现

正确的双指针解法使用快慢指针：

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

核心逻辑解析：

• slow指针：记录当前唯一元素的最后位置
• fast指针：探索新元素的前哨
• 当nums[fast] != nums[slow]时，说明发现新元素，将其复制到slow+1位置
• 最终slow+1就是不重复元素的数量

时间复杂度优化到O(n)，空间复杂度保持O(1)。

2.3 边界条件与易错点

在实际编码面试中，候选人常在这些地方翻车：

1. 空数组处理：忘记检查if not nums
2. 单元素数组：slow初始化为0可能导致越界
3. 指针移动条件：错误写成nums[fast] != nums[fast-1]
4. 返回值计算：误返回slow而非slow+1

实战技巧：建议先用[1,1,2]和[0,0,1,1,1,2,2,3,3,4]这两个测试用例手动模拟指针移动，加深理解。

3. 力扣27题：移除元素的进阶应用

3.1 问题变形与思维转换

力扣27题要求移除数组中所有等于给定值的元素，同样要求原地操作。看似与26题类似，但存在关键差异：

• 26题比较的是相邻元素
• 27题比较的是元素与固定目标值

暴力解法同样面临O(n²)时间复杂度问题：

python复制def removeElement(nums, val):
    i = 0
    while i < len(nums):
        if nums[i] == val:
            nums.pop(i)
        else:
            i += 1
    return len(nums)

3.2 双指针的两种实现模式

3.2.1 同向双指针（标准解法）

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

这种写法与26题高度相似，区别仅在于比较对象从nums[slow]变成了固定值val。

3.2.2 相向双指针（优化解法）

当要删除的元素很少时（如[1,2,3,4,5]中删除5），可以采用头尾指针：

python复制def removeElement(nums, val):
    left, right = 0, len(nums)
    while left < right:
        if nums[left] == val:
            nums[left] = nums[right-1]
            right -= 1
        else:
            left += 1
    return left

这种变体将最坏情况下的赋值操作从O(n)降到O(要删除的元素数量)。

3.3 性能对比与选择策略

在面试中，建议先实现同向双指针版本，如果面试官追问优化空间，再补充相向指针方案。

4. 双指针算法的通用解题框架

通过这两道经典题目，我们可以提炼出双指针算法的通用模式：

4.1 同向指针模板

python复制def two_pointers(nums):
    slow = 0  # 通常初始化为0或1
    for fast in range(len(nums)):
        if 满足特定条件:
            nums[slow] = nums[fast]
            slow += 1
    return slow  # 或slow+1根据题意调整

4.2 关键问题分解技巧

1. 确定指针含义：

   • slow通常表示有效区的边界
   • fast用于遍历和探索

2. 明确移动条件：

   • 什么情况下slow需要移动？
   • fast的步长是1还是可以跳跃？

3. 处理边界情况：

   • 空输入
   • 单元素数组
   • 全重复/全删除情况

4.3 相关题目扩展

掌握基础模式后，可以挑战这些变种题：

• 80. 删除有序数组中的重复项 II（允许最多重复两次）
• 283. 移动零（保持非零元素相对顺序）
• 844. 比较含退格的字符串（处理退格字符）
• 977. 有序数组的平方（利用相向指针)

5. 面试实战中的高频失误与应对

根据我参与过的数百场技术面试，候选人最容易在这些环节出错：

5.1 代码实现层面

• 指针初始值设置错误（特别是从0还是1开始）
• 循环条件写成fast <= len(nums)导致越界
• 忘记在元素交换/覆盖后移动指针
• 返回值计算错误（特别是从0开始计数时）

5.2 算法解释层面

• 无法清晰说明为什么双指针能降低复杂度
• 混淆快慢指针与滑动窗口的区别
• 不能正确分析算法的最坏/平均时间复杂度

5.3 优化建议

1. 先在白板上写出暴力解法，再引出优化思路
2. 用具体例子手动模拟指针移动过程
3. 主动讨论时间/空间复杂度的计算依据
4. 提前准备变种问题的应对策略

我在面试候选人时，最看重的不是能否一次性写出完美代码，而是能否通过沟通展示出对算法本质的理解。双指针问题尤其能考察候选人的问题分解能力和编码严谨性。