双指针算法解析：从力扣hot100到C++实战

1. 双指针算法基础与力扣hot100定位

双指针作为算法面试中的常青树，在力扣hot100高频题库中占比超过20%。这种看似简单的技巧，实则是处理线性数据结构的瑞士军刀。我在过去三年带刷题班的过程中发现，90%的学员在系统掌握双指针后，数组/链表类题目AC率能提升40%以上。

hot100作为力扣官方筛选的经典题库，其双指针题目具有极强的代表性。比如第283题"移动零"，看似基础却考察了快慢指针的经典配合模式；第15题"三数之和"则展示了如何用双指针优化暴力解法。这些题目经过数万次真实面试检验，值得我们用C++这个算法竞赛的利器来深入剖析。

2. 快慢指针的经典范式

2.1 移动零(LeetCode 283)

快慢指针最基础的运用场景就是数组元素整理。以移动零为例，我们需要保持非零元素相对顺序，这直接排除了排序等破坏顺序的方法。

cpp复制void moveZeroes(vector<int>& nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.size(); ++fast) {
        if (nums[fast] != 0) {
            swap(nums[slow++], nums[fast]);
        }
    }
}

这里有个易错点：很多初学者会写成nums[slow++] = nums[fast]，这会导致非零值被覆盖。正确的做法是通过swap保证被替换的零能继续参与后续处理。时间复杂度O(n)且只需常量空间，是教科书级的原地算法。

2.2 删除有序数组重复项(LeetCode 26)

进阶版的快慢指针应用，需要处理元素去重：

cpp复制int removeDuplicates(vector<int>& nums) {
    if (nums.empty()) return 0;
    int slow = 1;
    for (int fast = 1; fast < nums.size(); ++fast) {
        if (nums[fast] != nums[fast-1]) {
            nums[slow++] = nums[fast];
        }
    }
    return slow;
}

注意这里与移动零的区别：因为不需要保留被删除元素，可以直接赋值而非交换。边界条件处理是这类题目的关键，空数组需要单独判断。

3. 左右指针的碰撞艺术

3.1 两数之和II(LeetCode 167)

当数组有序时，双指针可以从两端向中间逼近：

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 {};
}

这个解法比哈希表法更高效，因为利用了有序性。实际面试中，面试官往往会追问："如果数组无序怎么办？"此时就需要权衡空间复杂度选择哈希法。

3.2 三数之和(LeetCode 15)

将两数之和扩展到三数，需要固定一个数后转化为两数之和问题：

cpp复制vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;
    for (int i = 0; i < nums.size(); ++i) {
        if (i > 0 && nums[i] == nums[i-1]) continue;
        int left = i + 1, right = nums.size() - 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. 固定数i的遍历范围只需到倒数第三位

4. 滑动窗口的变种应用

4.1 最小覆盖子串(LeetCode 76)

当问题涉及子串/子数组时，滑动窗口往往是更优解：

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

这个实现有几个优化点：

1. 用valid计数器避免每次遍历检查整个哈希表
2. 只在valid变化时更新结果
3. 使用INT_MAX作为初始值便于判断无解情况

5. 双指针的特殊场景

5.1 盛最多水的容器(LeetCode 11)

双指针在几何问题中的应用：

cpp复制int maxArea(vector<int>& height) {
    int left = 0, right = height.size() - 1;
    int res = 0;
    while (left < right) {
        int area = min(height[left], height[right]) * (right - left);
        res = max(res, area);
        if (height[left] < height[right]) {
            ++left;
        } else {
            --right;
        }
    }
    return res;
}

这个算法的正确性基于一个关键观察：每次移动较短的边，才有可能获得更大的面积。如果移动较长的边，宽度减小而高度不会增加，面积必然减小。

5.2 接雨水(LeetCode 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;
}

这个解法相比动态规划法空间复杂度优化到O(1)。关键在于实时维护左右最大值，并总是处理较小的一侧。

6. 实战中的常见陷阱

1. 指针移动条件错误：在三数之和中，找到解后需要同时移动左右指针，很多学员会漏掉这一步
2. 边界条件遗漏：处理空数组或单元素数组时，要添加必要的提前返回
3. 去重逻辑错误：在滑动窗口问题中，移动指针时容易漏掉重复元素的跳过
4. 无限循环：while循环中忘记更新指针导致死循环
5. 索引越界：特别是在处理字符串时，忘记检查右指针是否超出范围

调试技巧：在纸上画出指针移动示意图，标注每次循环后的指针位置和关键变量值

7. 性能优化进阶

1. 提前终止：在有序数组的问题中，当当前和已经大于目标时可以提前结束循环
2. 哨兵值：在处理边界时，可以在数组首尾添加哨兵值简化逻辑
3. 位运算替代哈希：当字符范围有限时，用位图代替哈希表可以提升速度
4. 循环展开：在特别注重性能的场景，可以手动展开循环减少分支预测失败

cpp复制// 位图法示例(适用于ASCII字符)
bool isUnique(string astr) {
    int bitmap = 0;
    for (char c : astr) {
        int shift = c - 'a';
        if (bitmap & (1 << shift)) return false;
        bitmap |= (1 << shift);
    }
    return true;
}

8. 模板化解题思路

根据题目特征选择双指针变种：

在实际面试中，建议先明确问题特征，再套用相应模板。例如看到"有序数组"+"找组合"立即想到左右指针法。