双指针算法实战：从原理到LeetCode经典题解

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

双指针算法是解决数组和链表问题的利器，其核心在于通过两个指针的协同移动来降低时间复杂度。在Java中实现双指针时，通常有以下几种典型模式：

1. 快慢指针：常用于链表环检测、数组去重等问题。快指针负责探索，慢指针负责构建结果。
2. 左右指针：适用于有序数组的两数之和、反转数组等问题。指针从两端向中间移动。
3. 滑动窗口：解决子串/子数组问题，通过动态调整窗口边界来寻找最优解。

以LeetCode 283题为例，我们使用快慢指针实现O(n)时间复杂度的零元素移动：

java复制// 快指针j遍历数组，慢指针i记录非零元素位置
int i = 0;
for(int j = 0; j < nums.length; j++){
    if(nums[j] != 0){
        nums[i++] = nums[j]; // 非零元素前移
    }
}
// 剩余位置补零
while(i < nums.length){
    nums[i++] = 0;
}

关键技巧：当遇到需要保持元素原始顺序的问题时，快指针的扫描顺序必须与原始顺序一致，这是保证稳定性的关键。

2. 盛水容器问题深度剖析

LeetCode 11题看似简单，实则蕴含着经典的双指针优化思想。其核心公式为：

code复制面积 = 距离 × min(左高度, 右高度)

2.1 算法优化过程

1. 暴力解法：双重循环计算所有可能组合，时间复杂度O(n²)
2. 双指针优化：从两端向中间移动，每次移动较矮的指针，时间复杂度降至O(n)

java复制public int maxArea(int[] height) {
    int left = 0, right = height.length - 1;
    int max = 0;
    while(left < right){
        int current = (right - left) * Math.min(height[left], height[right]);
        max = Math.max(max, current);
        // 关键决策：移动较矮的一侧
        if(height[left] < height[right]){
            left++;
        }else{
            right--;
        }
    }
    return max;
}

2.2 数学证明

为什么移动较矮的指针是正确的？假设height[left] < height[right]：

• 移动right：距离必然减小，且高度受限于min(height[left], height[new_right]) ≤ height[left]
• 移动left：虽然距离减小，但可能找到更高的height[new_left]

因此移动较矮指针保留了找到更大面积的可能性。

3. 三数之和的完整实现方案

LeetCode 15题是双指针的经典应用，需要处理去重和边界条件等复杂情况。

3.1 解题步骤分解

1. 排序预处理：Arrays.sort(nums) —— 时间复杂度O(nlogn)
2. 固定第一个数：遍历数组，跳过重复值
3. 双指针搜索：在剩余区间寻找两数之和等于-target

java复制public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> res = new ArrayList<>();
    for(int i = 0; i < nums.length - 2; i++){
        // 去重处理
        if(i > 0 && nums[i] == nums[i-1]) continue;
        
        int left = i + 1, right = nums.length - 1;
        while(left < right){
            int sum = nums[i] + nums[left] + nums[right];
            if(sum == 0){
                res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                // 跳过重复元素
                while(left < right && nums[left] == nums[left+1]) left++;
                while(left < right && nums[right] == nums[right-1]) right--;
                left++;
                right--;
            }else if(sum < 0){
                left++;
            }else{
                right--;
            }
        }
    }
    return res;
}

3.2 边界条件处理

• 数组长度不足3：直接返回空列表
• 全零情况：需要正确处理而不是跳过
• 整数溢出：本题限定在int范围内，但类似问题需要考虑大数情况

4. 接雨水问题的三维解法

LeetCode 42题有多种解法，其中双指针方案最为高效。理解其物理意义至关重要。

4.1 动态规划解法

java复制public int trap(int[] height) {
    int n = height.length;
    if(n == 0) return 0;
    
    // 从左向右扫描的最大高度
    int[] leftMax = new int[n];
    leftMax[0] = height[0];
    for(int i = 1; i < n; i++){
        leftMax[i] = Math.max(height[i], leftMax[i-1]);
    }
    
    // 从右向左扫描的最大高度
    int[] rightMax = new int[n];
    rightMax[n-1] = height[n-1];
    for(int i = n-2; i >= 0; i--){
        rightMax[i] = Math.max(height[i], rightMax[i+1]);
    }
    
    // 计算每个位置的积水量
    int ans = 0;
    for(int i = 0; i < n; i++){
        ans += Math.min(leftMax[i], rightMax[i]) - height[i];
    }
    return ans;
}

4.2 双指针优化

空间复杂度可从O(n)优化到O(1)：

java复制public int trap(int[] height) {
    int left = 0, right = height.length - 1;
    int leftMax = 0, rightMax = 0;
    int ans = 0;
    
    while(left < right){
        if(height[left] < height[right]){
            if(height[left] >= leftMax){
                leftMax = height[left];
            }else{
                ans += leftMax - height[left];
            }
            left++;
        }else{
            if(height[right] >= rightMax){
                rightMax = height[right];
            }else{
                ans += rightMax - height[right];
            }
            right--;
        }
    }
    return ans;
}

物理意义：每个位置的积水量由左右两侧最高柱子的较小值决定，这解释了为什么可以用Math.min(leftMax, rightMax)计算。

5. 双指针算法的常见陷阱与优化

5.1 典型错误案例

1. 指针移动条件错误：在盛水容器问题中错误地移动较高的指针
2. 边界条件遗漏：三数之和中忘记处理数组长度不足的情况
3. 去重逻辑缺陷：在找到有效解后只移动一个指针

5.2 性能优化技巧

1. 提前终止：当剩余元素不可能产生更好解时提前退出循环
2. 预处理：对数组进行排序等操作虽然增加O(nlogn)时间，但可能大幅降低后续操作复杂度
3. 空间复用：如接雨水问题中复用输入数组存储中间结果

5.3 调试建议

1. 小数据测试：用长度为0、1、2的数组验证边界条件
2. 打印指针轨迹：在循环中加入日志输出指针位置和关键变量
3. 可视化分析：对于接雨水等问题，绘制柱状图辅助理解

在实际面试中，建议先明确说明双指针的移动策略和终止条件，再开始编码。例如解决盛水容器问题时可以这样表述："我们将维护左右两个指针，每次移动高度较小的指针，因为这样才有可能获得更大的面积。当指针相遇时算法终止。"