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

1. 双指针算法核心思想解析

双指针算法（Two Pointers Technique）是解决数组和链表问题的利器，其本质是通过维护两个或多个指针的协同移动来降低问题的时间复杂度。在实际编码面试中，约30%的中等难度题目可以通过双指针思路高效解决。根据指针移动方式的不同，主要分为三种经典模式：

快慢指针（Fast-Slow Pointers）通常用于检测循环或寻找中位数。快指针每次移动两步，慢指针每次移动一步，当快指针到达末尾时，慢指针正好位于中间位置。这种模式将遍历次数从O(n²)优化到O(n)，空间复杂度保持O(1)。

对撞指针（Collision Pointers）适用于已排序数组的搜索问题。通过初始化左指针在起始位置、右指针在末尾，根据条件向中间移动指针，直到两者相遇。典型的应用场景包括两数之和、三数之和等问题，可将暴力解法的O(n³)优化到O(n²)。

滑动窗口（Sliding Window）是处理子数组/子字符串问题的有效方法。通过动态调整窗口的左右边界来寻找满足条件的区间，避免了重复计算。最大特点是右指针主动扩展窗口，左指针被动收缩窗口，时间复杂度通常为O(n)。

关键理解：双指针不是独立算法，而是一种通过指针协同来减少无效计算的优化思想。其威力在于将嵌套循环转化为单次遍历，同时保持空间效率。

2. LeetCode 283 - 移动零的三种解法对比

题目要求将数组中的零元素移动到末尾，同时保持非零元素的相对顺序。表面简单，但隐藏着对空间复杂度的考察。

2.1 暴力解法与空间优化

最直观的方法是创建新数组，遍历原数组两次：第一次收集非零元素，第二次补零。这种方法需要O(n)额外空间，不符合题目要求的原地修改（in-place）。

python复制def moveZeroes_naive(nums):
    non_zeros = [x for x in nums if x != 0]
    return non_zeros + [0] * (len(nums) - len(non_zeros))

2.2 快慢指针标准解法

维护慢指针指向下一个非零元素的插入位置，快指针遍历数组。当快指针遇到非零元素时，将其与慢指针位置交换，然后双指针同时前进；遇到零时仅快指针前进。这种解法只需O(1)空间。

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

2.3 优化交换次数的变种

当数组前段存在连续非零元素时，标准解法会执行不必要的自身交换。改进方案是先移动非零元素，最后统一补零：

python复制def moveZeroes_optimized(nums):
    slow = 0
    for num in nums:
        if num != 0:
            nums[slow] = num
            slow += 1
    for i in range(slow, len(nums)):
        nums[i] = 0

实测数据对比（10000个元素数组）：

3. LeetCode 11 - 盛水容器的数学证明

题目要求在给定的高度数组中找到两条线，使其与x轴构成的容器能容纳最多的水。暴力解法需要检查所有O(n²)可能的组合，而双指针可优化到O(n)。

3.1 对撞指针的正确性证明

初始化指针在两端，每次移动较短边的指针。这个策略有效的核心原因在于：

• 容器容量由较短边和宽度共同决定
• 移动较长边不可能增加容量（因为高度受限于更短的边，而宽度必然减少）
• 只有移动较短边才有可能遇到更高的边界，从而可能增加容量

python复制def maxArea(height):
    left, right = 0, len(height) - 1
    max_water = 0
    while left < right:
        current = min(height[left], height[right]) * (right - left)
        max_water = max(max_water, current)
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return max_water

3.2 边界条件处理

当高度数组存在多个等高峰值时，算法仍能正确工作。因为无论移动哪个指针，另一个指针最终都会遍历到所有可能的峰值组合。实测表明，对于[1,8,6,2,5,4,8,3,7]的典型输入，算法会在left=1(height=8)和right=8(height=7)时找到最大值49。

4. LeetCode 15 - 三数之和的去重技巧

这是双指针应用的经典难题，要求在数组中找到所有不重复的三元组，使其和为0。关键在于高效去重和剪枝。

4.1 排序预处理与循环结构

首先对数组排序（O(nlogn)），然后固定第一个数，在其右侧区间使用对撞指针寻找另外两个数。固定数的循环需要跳过重复值：

python复制def threeSum(nums):
    nums.sort()
    res = []
    for i in range(len(nums)-2):
        if i > 0 and nums[i] == nums[i-1]:  # 去重关键
            continue
        left, right = i+1, len(nums)-1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if s < 0:
                left += 1
            elif s > 0:
                right -= 1
            else:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:  # 左指针去重
                    left += 1
                while left < right and nums[right] == nums[right-1]:  # 右指针去重
                    right -= 1
                left += 1
                right -= 1
    return res

4.2 剪枝优化

在固定第一个数时，可以进行早期终止判断：

• 如果nums[i] > 0，由于数组已排序，后面不可能找到和为0的组合
• 如果nums[i] + nums[i+1] + nums[i+2] > 0，当前最小值已过大
• 如果nums[i] + nums[-2] + nums[-1] < 0，当前最大值仍不足

这些优化可以将平均时间复杂度从O(n²)降低到实际运行时的O(nlogn + kn)，其中k是有效解的个数。

5. LeetCode 42 - 接雨水的动态规划与双指针

这是双指针算法的高阶应用，需要理解局部最高点的动态维护。

5.1 暴力解法的瓶颈

对于每个位置，计算其左侧最高和右侧最高，取较小值减去当前高度。这种方法需要O(n²)时间，在大数据量时不可行。

5.2 双指针的优化思路

维护左右指针和当前已知的左右最大值。每次移动较小max侧的指针，因为积水高度由较小max决定：

python复制def trap(height):
    left, right = 0, len(height) - 1
    left_max = right_max = water = 0
    while left <= right:
        if left_max <= right_max:
            left_max = max(left_max, height[left])
            water += left_max - height[left]
            left += 1
        else:
            right_max = max(right_max, height[right])
            water += right_max - height[right]
            right -= 1
    return water

5.3 算法正确性验证

以height = [0,1,0,2,1,0,1,3,2,1,2,1]为例：

1. 初始left=0, right=11, left_max=0, right_max=1
2. 移动左指针到1，更新left_max=1
3. 移动左指针到2，积水+=1-0=1
4. 移动左指针到3，更新left_max=2
5. 移动左指针到4，积水+=2-1=1
6. 继续此过程直到指针相遇

这种单次遍历的方法将时间复杂度优化到O(n)，空间复杂度保持O(1)，是面试官最期待的解法。

6. 双指针算法的通用解题模板

通过以上四题可以总结出双指针的通用思考框架：

1. 确定指针初始位置（通常为头尾或同起点）
2. 明确指针移动条件（基于值比较或特定规则）
3. 处理指针移动时的边界条件（数组越界、重复值等）
4. 维护必要的辅助变量（当前最大值、累计值等）
5. 确定终止条件（指针相遇或达到特定状态）

对于不同问题，可以套用以下伪代码模板：

python复制def two_pointers_template(nums):
    left, right = init_position(nums)  # 初始化指针位置
    result = 0
    while termination_condition(left, right):  # 终止条件
        if should_move_left(left, right, nums):  # 移动条件判断
            update_left_state()  # 状态更新
            left += 1
        else:
            update_right_state()
            right -= 1
        check_result_condition()  # 结果判断
    return result

在实际面试中，建议先明确说明选择双指针的原因（通常是降低时间复杂度），然后逐步推导指针移动的逻辑，最后讨论边界情况和可能的优化空间。