双指针算法详解：原理、类型与LeetCode实战

1. 为什么双指针问题总让人又爱又恨？

我第一次接触双指针算法是在LeetCode的第15题（三数之和）。当时盯着题目看了半小时，脑子里全是暴力解法的三重循环。直到看到评论区有人提到"双指针可以将O(n³)降到O(n²)"，我才意识到这个看似简单的技巧背后藏着巨大的威力。

双指针的核心思想其实非常直观：通过两个指针的协同移动，在单次遍历中完成需要多重循环的任务。这种技巧在数组、链表等线性结构的问题中尤其有效。但真正让我头疼的是，看似相似的问题，双指针的移动规则可能完全不同。比如快慢指针找链表环的入口，和有序数组的两数之和，虽然都用到了双指针，但指针移动的逻辑却大相径庭。

关键认知：双指针不是一种固定模式，而是一类解题思路的统称。不同类型的双指针问题需要不同的移动策略和边界条件处理。

2. 双指针的三大经典类型与C++实现

2.1 同向快慢指针

这是链表问题中最常见的双指针用法。快指针每次移动两步，慢指针每次移动一步，可以用来检测环、找中点等。

cpp复制// 检测链表是否有环
bool hasCycle(ListNode *head) {
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) return true;
    }
    return false;
}

实际编码时最容易犯的错误是边界条件处理。比如上面的fast->next判断，如果漏掉，当fast为nullptr时访问fast->next就会导致段错误。我在初学时就因为这个错误调试了半小时。

2.2 相向双指针

常用于有序数组的问题，比如两数之和、三数之和等。一个指针从头部开始，一个从尾部开始，根据条件向中间移动。

cpp复制// 有序数组的两数之和
vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size() - 1;
    while (left < right) {
        int sum = numbers[left] + numbers[right];
        if (sum == target) return {left+1, right+1};
        else if (sum < target) left++;
        else right--;
    }
    return {};
}

这里有个性能优化的小技巧：如果数组元素范围已知，可以在移动指针时跳过重复值。比如在三数之和问题中，这样可以避免重复解的判断。

2.3 滑动窗口

严格来说滑动窗口是双指针的一种特殊形式，用于解决子串/子数组问题。我最初很难理解为什么滑动窗口能保证不遗漏解，直到自己画图分析了几次窗口的移动过程。

cpp复制// 最小覆盖子串
string minWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;
    
    int left = 0, right = 0;
    int valid = 0;
    int start = 0, len = INT_MAX;
    
    while (right < s.size()) {
        char c = s[right];
        right++;
        if (need.count(c)) {
            window[c]++;
            if (window[c] == need[c]) valid++;
        }
        
        while (valid == need.size()) {
            if (right - left < len) {
                start = left;
                len = right - left;
            }
            char d = s[left];
            left++;
            if (need.count(d)) {
                if (window[d] == need[d]) valid--;
                window[d]--;
            }
        }
    }
    return len == INT_MAX ? "" : s.substr(start, len);
}

这个实现中有几个关键点：

1. need字典记录所需字符及其出现次数
2. window字典记录当前窗口中的字符统计
3. valid计数器表示满足条件的字符数量

3. LeetCode经典题目深度解析

3.1 三数之和（第15题）

这是双指针的经典应用场景。暴力解法需要O(n³)的时间复杂度，而通过排序+双指针可以优化到O(n²)。

cpp复制vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;
    int n = nums.size();
    
    for (int i = 0; i < n - 2; i++) {
        if (i > 0 && nums[i] == nums[i-1]) continue; // 去重
        
        int left = i + 1, right = n - 1;
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                res.push_back({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;
}

这个解法有几个容易出错的地方：

1. 忘记先排序数组
2. 没有处理重复三元组的情况
3. 双指针移动时边界条件处理不当

3.2 接雨水（第42题）

这道题的双指针解法非常巧妙，需要理解如何通过左右指针的移动来计算每个位置能接的雨水量。

cpp复制int trap(vector<int>& height) {
    int left = 0, right = height.size() - 1;
    int left_max = 0, right_max = 0;
    int res = 0;
    
    while (left < right) {
        if (height[left] < height[right]) {
            height[left] >= left_max ? 
                left_max = height[left] : res += left_max - height[left];
            left++;
        } else {
            height[right] >= right_max ? 
                right_max = height[right] : res += right_max - height[right];
            right--;
        }
    }
    return res;
}

这个解法的核心思想是：

• 使用两个指针从两端向中间移动
• 维护左右两边的最大值
• 每次处理较矮的那一边，因为它的水量由这一侧的最大值决定

3.3 无重复字符的最长子串（第3题）

滑动窗口的典型应用，需要用一个哈希集合来记录窗口中的字符。

cpp复制int lengthOfLongestSubstring(string s) {
    unordered_set<char> window;
    int left = 0, right = 0;
    int res = 0;
    
    while (right < s.size()) {
        if (!window.count(s[right])) {
            window.insert(s[right]);
            right++;
            res = max(res, right - left);
        } else {
            window.erase(s[left]);
            left++;
        }
    }
    return res;
}

优化点：可以用哈希表记录字符索引，这样左指针可以直接跳到重复字符的下一个位置，而不是一步步移动。

4. 双指针问题的调试技巧与常见陷阱

4.1 指针越界问题

这是双指针算法中最常见的错误类型。比如在快慢指针问题中，快指针每次移动两步，必须检查fast->next是否为nullptr。

cpp复制while (fast && fast->next) {  // 正确的边界检查
    // ...
}

4.2 无限循环问题

特别是在滑动窗口问题中，如果指针移动条件写错，很容易导致无限循环。我的经验是：

1. 在循环开始前明确终止条件
2. 在循环体内确保至少有一个指针会移动
3. 对于复杂条件，添加调试输出打印指针位置

4.3 处理重复元素

很多双指针问题需要处理重复解，如三数之和。常见的处理方式是：

1. 先排序数组
2. 当找到一个解后，跳过所有相同的元素

cpp复制while (left < right && nums[left] == nums[left+1]) left++;
while (left < right && nums[right] == nums[right-1]) right--;

4.4 性能优化技巧

1. 提前终止：在某些问题中，当发现不可能有更好解时可以提前退出循环
2. 跳过不可能的解：如在三数之和中，如果第一个数已经大于0，可以直接break
3. 使用更高效的数据结构：比如用数组代替哈希表来记录字符出现次数（当字符集较小时）

5. 如何识别双指针适用的问题场景

经过大量练习后，我总结出几个双指针适用的典型特征：

1. 线性数据结构：数组、链表、字符串等问题
2. 需要比较或组合元素：如找满足条件的两个/三个元素
3. 涉及子区间/子串：如最长无重复子串、最小覆盖子串等
4. 有序或可排序的数据：排序后往往能简化双指针的移动逻辑

当遇到这类问题时，可以优先考虑双指针解法。不过要注意，有些问题虽然可以用双指针，但可能不是最优解。比如某些动态规划问题用双指针可能难以处理所有边界情况。

在实际面试中，我通常会先提出暴力解法，然后分析其时间复杂度，再考虑如何用双指针进行优化。这种解题思路的展示往往能给面试官留下好印象。