C++学习笔记进阶（二）：双指针

双指针

定义

这是一个非常常见的算法，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。

换言之，双指针法充分使用了数组有序这一特征，从而在某些情况下能够简化一些运算。

移动零

这题的目标在于将数组中的零全部移到数组最右边。

考虑后我们应该使用快慢指针。使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。

注意到以下性质：

左指针左边均为非零数；

右指针左边直到左指针处均为零。

因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。

移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};

盛最多水的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。

这题说起来难度并不大，因为已经提示了使用双指针(而且是对撞指针)。只需要注意到每次移动较小的那个指针即可

盛最多水的容器

class Solution {
public:
    int maxArea(vector<int>& height) {
        int max_area = 0;
        int i = 0; 
        int j = height.size() - 1; 

        while (i < j) { 
            int current_area = (j - i) * std::min(height[i], height[j]);
            max_area = std::max(max_area, current_area); 

            if (height[i] < height[j])
                i++;
            else
                j--;
        }

        return max_area; 
    }
};

三数之和

在数组中找到三元组的和为0。

首先思路要足够清晰。三元组使用双指针，首先是要固定一个的值，然后双指针对撞。

需要注意，两个三元组不能重复，这就要求有continue条件

三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end()); // 对数组进行排序，以便后续操作
        vector<vector<int>> answer; // 存储结果的二维向量
        
        for (int i = 0; i < n - 2; i++) { // 遍历数组，固定第一个元素
            // 避免重复的固定元素
            if (i > 0 && nums[i] == nums[i - 1])
                continue;

            int left = i + 1; // 左指针指向固定元素的下一位
            int right = n - 1; // 右指针指向数组末尾
            
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right]; // 计算三个元素的和

                if (sum < 0) { // 如果和小于零，说明需要增大和，左指针右移一位
                    left++;
                }
                else if (sum > 0) { // 如果和大于零，说明需要减小和，右指针左移一位
                    right--;
                }
                else { // 和等于零，找到满足条件的三元组
                    answer.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--; // 右指针左移一位
                }
            }
        }  
        return answer;
    }
};

接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

这题好像有点难，对于下标 $i$, 下雨后水能到达的最大高度等于下标 $i$ 两边的最大高度的最小值, 下标 $i$处能接的雨水量等于下标 $i$ 处的水能到达的最大高度减去 height $[i]$ 。

朴素的做法是对于数组 height 中的每个元素, 分别向左和向右扫描并记录左边和右边的最大高度, 然后计算每个下标位置能接的雨水量。假设数组 height 的长度为 $n$, 该做法需要对每个下标位置使用 $O(n)$ 的时间向两边扫描并得到最大高度, 因此总时间复杂度是 $O\left(n^2\right)$ 。

上述做法的时间复杂度较高是因为需要对每个下标位置都向两边扫描。如果已经知道每个位置两边的最大高度, 则可以在 $O(n)$ 的时间内得到能接的雨水总量。使用动态规划的方法, 可以在 $O(n)$ 的时间内预处理得到每个位置两边的最大高度。

创建两个长度为 $n$ 的数组 leftMax 和 rightMax。对于 $0\le i<n$, leftMax $[i]$ 表示下标 $i$ 及其左边的位置中, height 的最大高度, rightMax $[i]$ 表示下标 $i$ 及其右边的位置中, height 的最大高度。

显然, $\mathrm{leftMax}[0]=height[0],\mathrm{rightMax}[n-1]=height[n-1]$ 。两个数组的其余元素的计算如下:

• 当 $1\le i\le n-1$ 时, leftMax $[i]=\max ($ leftMax $[i-1]$, height $[i])$ ；
• 当 $0\le i\le n-2$ 时, $\mathrm{rightMax}[i]=\max (\mathrm{rightMax}[i+1]$, height $[i])$ 。

因此可以正向遍历数组 height 得到数组 leftMax 的每个元素值, 反向遍历数组 height 得到数组 rightMax 的每个元素值。

在得到数组 leftMax 和 rightMax 的每个元素值之后, 对于 $0\le i<n$, 下标 $i$ 处能接的雨水量等于 $\min ($ leftMax $[i]$, rightMax $[i])-height[i]$ 。遍历每个下标位置即可得到能接的雨水总量。

接雨水

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if (n == 0) {
            return 0;
        }
        vector<int> leftMax(n);
        leftMax[0] = height[0];
        for (int i = 1; i < n; ++i) {
            leftMax[i] = max(leftMax[i - 1], height[i]);
        }

        vector<int> rightMax(n);
        rightMax[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            rightMax[i] = max(rightMax[i + 1], height[i]);
        }

        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += min(leftMax[i], rightMax[i]) - height[i];
        }
        return ans;
    }
};