双指针算法：原理、实现与高频题型解析

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

双指针技术是算法领域最经典的解题范式之一，尤其在处理线性数据结构时展现出极高的效率。这种技术通过维护两个按特定规律移动的指针（通常称为快慢指针或左右指针），将原本O(n²)的时间复杂度优化到O(n)级别。在Java实现中，指针通常表现为数组索引或链表节点的引用。

1.1 技术实现原理

双指针的工作机制主要分为三种典型模式：

• 同向移动：两个指针从同一侧出发，以不同速度前进（如快慢指针判环）
• 相向移动：指针分别从首尾向中间靠拢（如二分查找变种）
• 滑动窗口：维护一个动态变化的区间（如子串匹配问题）

java复制// 经典同向双指针模板
public void twoPointers(int[] nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.length; fast++) {
        if (condition) {
            nums[slow++] = nums[fast];
        }
    }
}

1.2 适用场景分析

双指针特别适合解决以下六类问题：

1. 有序数组的元素查找（两数之和）
2. 去重或特定值过滤（移除元素）
3. 链表结构操作（环检测、交点查找）
4. 子数组/子串问题（最小覆盖子串）
5. 容器类问题（盛最多水的容器）
6. 归并类操作（合并有序数组）

经验提示：当问题描述中出现"有序"、"连续"、"子集"等关键词时，应优先考虑双指针解法

2. Hot100高频题型深度剖析

2.1 两数之和变种（LeetCode 167）

有序数组的特殊性质使得双指针可以替代哈希表解法，获得更优的空间复杂度：

java复制public int[] twoSum(int[] numbers, int target) {
    int left = 0, right = numbers.length - 1;
    while (left < right) {
        int sum = numbers[left] + numbers[right];
        if (sum == target) {
            return new int[]{left + 1, right + 1};
        } else if (sum < target) {
            left++;
        } else {
            right--;
        }
    }
    return new int[]{-1, -1};
}

复杂度对比：

2.2 盛水容器问题（LeetCode 11）

该问题需要理解短板效应与指针移动策略的关系：

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

移动策略证明：

• 假设height[left] < height[right]，若移动right指针：
  • 新right可能比原right高或低
  • 宽度必然减小，而高度受限于原left
  • 容量必定减小
• 因此必须移动较矮的一侧才可能获得更大容量

2.3 三数之和（LeetCode 15）

该问题需要结合排序与双指针，注意去重逻辑的实现：

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. 边界条件与调试技巧

3.1 常见越界场景

1. 空指针异常：

   • 链表问题中未检查next是否为null
   • 数组问题中未处理length=0的情况

2. 索引越界：

   • while循环中同时移动两个指针时缺少边界检查
   • 滑动窗口右边界超出数组长度

3. 整数溢出：

   • 容器类问题中宽度与高度的乘积
   • 累加和问题中的sum累计

3.2 调试日志模板

在复杂双指针问题中添加 strategic log：

java复制System.out.printf("L:%d(%d) R:%d(%d) | Sum:%d%n", 
    left, nums[left], 
    right, nums[right],
    nums[left] + nums[right]);

3.3 测试用例设计指南

4. 性能优化进阶策略

4.1 早期终止优化

在某些问题中可以通过额外条件判断提前结束循环：

java复制// 在盛水容器问题中
if (height[left] > maxHeight && height[right] > maxHeight) {
    max = Math.max(max, Math.min(height[left], height[right]) * (right - left));
    maxHeight = Math.max(height[left], height[right]);
}

4.2 空间复用技巧

对于需要修改原数组的题目，合理利用指针位置：

java复制// 移除元素问题（LeetCode 27）
public int removeElement(int[] nums, int val) {
    int k = 0;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] != val) {
            nums[k++] = nums[i];  // 原地修改数组
        }
    }
    return k;
}

4.3 多指针协同

复杂问题可能需要三个甚至更多指针协同工作：

java复制// 颜色分类问题（LeetCode 75）
public void sortColors(int[] nums) {
    int p0 = 0, p2 = nums.length - 1;
    int curr = 0;
    while (curr <= p2) {
        if (nums[curr] == 0) {
            swap(nums, curr++, p0++);
        } else if (nums[curr] == 2) {
            swap(nums, curr, p2--);  // 注意curr不增加
        } else {
            curr++;
        }
    }
}

5. 同类问题扩展训练

5.1 链表类双指针

1. 环形链表检测（LeetCode 141）
2. 相交链表查找（LeetCode 160）
3. 删除倒数第N个节点（LeetCode 19）

java复制// 快慢指针找链表中点模板
ListNode slow = head, fast = head;
while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
}

5.2 字符串类应用

1. 验证回文串（LeetCode 125）
2. 反转字符串（LeetCode 344）
3. 最小覆盖子串（LeetCode 76）

java复制// 回文串验证优化版
public boolean isPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    while (left < right) {
        while (left < right && !Character.isLetterOrDigit(s.charAt(left))) left++;
        while (left < right && !Character.isLetterOrDigit(s.charAt(right))) right--;
        if (Character.toLowerCase(s.charAt(left++)) != 
            Character.toLowerCase(s.charAt(right--))) {
            return false;
        }
    }
    return true;
}

5.3 滑动窗口专题

1. 无重复字符的最长子串（LeetCode 3）
2. 字符串的排列（LeetCode 567）
3. 最大连续1的个数（LeetCode 487）

java复制// 滑动窗口通用模板
Map<Character, Integer> window = new HashMap<>();
int left = 0, right = 0;
while (right < s.length()) {
    char c = s.charAt(right++);
    window.put(c, window.getOrDefault(c, 0) + 1);
    
    while (window needs shrink) {
        char d = s.charAt(left++);
        window.put(d, window.get(d) - 1);
    }
}

在实际刷题过程中，建议将同类型题目集中训练，对比不同问题的指针移动策略差异。对于每道题目，至少手写实现3遍：第一遍理解思路，第二遍优化代码，第三遍尝试不同解法。