双指针算法大总结！！看完这篇再也没有难的双指针题！！例题C++解法！

题源acwing、力扣

讲解双指针
题目一：盛最多水的容器
- 思路
- AC代码
题目二：查找总价格为目标值的两个商品
- 思路
- AC代码
题目三：链表的中间节点
- 思路
- AC代码
题目四：环形链表
- 思路
- AC代码
题目五：反转字符串中的元音字符
- 思路
- AC代码
题目六：最长连续不重复子序列
- 思路
- AC代码
题目七：判断子序列
- 思路
- AC代码

讲解双指针

使用双指针是降低算法复杂度的一个有效途径，有些问题的暴力解法时间O(n²)，但是使用双指针可以大幅度降低算法复杂度。
和贪心算法一样，双指针难在想不到
常用的双指针法有以下几类：
左右指针：两个指针，相向而走，中间相遇
快慢指针：两个指针，有快有慢，同向而行
灵活运用：两个指针，灵活运用，伺机而动
下面从例题里感受这三类情况

题目一二是左右指针
题目三四是快慢指针

题目一：盛最多水的容器

题源力扣11.点击跳转力扣

给定一个长度为 n 的整数数组 height 。
有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。
在这里插入图片描述
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

思路

最优解法为左右双指针算法，双指针法的难点在于难以想到也难以证明，需要大量的刷题去练习题感
暴力法：
找出每一种情况，求出盛水值，最大的就是答案

i 指左挡板，从第一块到遍历倒数第二块
j 指右挡板，从倒数第一块遍历到 i 后面一块
res 保存最大值，不断更新
返回 res

class Solution{
public：
	int maxArea(vector<int>& height){
		if(height.size() <= 1) return 0;
		int res = 0;
		for(int i = 0; i < height.size() - 1; i ++)//以 i 为左挡板，从 0 开始
			for(int j = height.size() - 1; j > i; j --){
				int l = j - i;//底边
				int h = min(height[i], height[j]);
				res = max(res, l * h);
			}
		return res;
	}
}

答案正确，但是会超时，双指针算法还有可以优化的空间

优化：
假设S[l，r]为左挡板为l，右挡板为r的盛水值，那么我们有多少种情况？
在这里插入图片描述
再回顾一下，height数组[1,8,6,2,5,4,8,3,7]
暴力法里面，我们将所有情况都计算了一遍，实际上有很多情况不需要计算，因为一定不是答案
假设现在挡板是S[0，8]，左高度是1，右高度是7，其中低一点高度的是1，现在移动右挡板还有意义吗？
没有意义
只要是向内移动右挡板，底边长一定变短，如果移动后高度比1高，就会变成底边长变短，高度不变，盛水量变小
只要是向内移动右挡板，底边长一定变短，如果移动后高度比1低，就会变成底边长变短，高度变低，盛水量变小

那么移动左挡板有意义吗？
有意义
只要是向内移动左挡板，底边长一定变短，移动后如果比1高，就会是底边长变短，高度变高，这种情况值得计算！

所以总结一下就是，每一种S[l，r]的情况下，计算后需要比较 l 和 r 的高度，如果height[l] < height[r]就执行 l ++
如果height[l] > height[r]就执行 r –

AC代码

class Solution {
public:
    int maxArea(vector<int>& height) {
        int l = 0;
        int r = height.size() - 1;
        int res = 0;
        while(l < r){
            res = max(min(height[l], height[r]) * (r - l), res);
            if(height[l] < height[r]){
                l ++;
            }else{
                r --;
            }
        }
        return res;
    }
};

题目二：查找总价格为目标值的两个商品

题源力扣179.点击跳转力扣

购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。

思路

题目很容易想到双指针，但是如果不留意冗余情况也容易超时
暴力法：
穷举每一种情况，如果两数之和等于target，就输出答案

i 指向第一个数，从 0 到 price,size() - 2
j 指向第二个数，从price.size() -1 到 i + 1
如果price[i] + price[j] == target，返回price[i], price[j]]
不贴代码了，因为我感觉没人会真的暴力吧，不会吧不会吧(罒ω罒)

优化
暴力法显然没有考虑到数组有序的条件
小时候听说过1+2+3+…+99，问有多少个100，巧妙算法咋算的？是不是头加尾，1 + 99， 2 + 98…
这题也是一样的
j 应该从price.size() - 1开始
不多说了，这题很容易想

AC代码

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
        int j = price.size() - 1;
        for(int i = 0; i < price.size() - 2; i ++){
            while((price[i] + price[j]) > target) j --;
            if(price[i] + price[j] == target) return vector<int>{price[i], price[j]};
        }
        return {-1, -1};
    }
};

题目三：链表的中间节点

题源力扣876.点击跳转力扣

给你单链表的头结点 head ，请你找出并返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
在这里插入图片描述
这题是快慢指针，快慢指针是指移动的步长，即每次向前移动速度的快慢。（例如，让快指针每次前移动2步，慢指针每次向前移动1步）。

思路

暴力法：

用一个指针遍历一遍链表，求出链表的最后一个节点编号n
中间节点为n/2，向上取整
用一个指针从表头往后走n/2向上取整步，指向的节点就是答案

class Solution{
public：
	ListNode* middleNode(ListNode* head) {
		if(!head) return NULL;
		int n = 0;
		ListNode *p = head;
		while(p->next){
			n ++;
			p = p->next;
		}
		int mid = (n + 1) / 2;
		p = head;
		while(mid --){
			p = p->next;
		}
		return p;
	}
}

暴力法可以AC，但是还有优化的空间

优化：
快慢指针，想象两个人跑步，一个人速度是另一个人的两倍，当速度快的到达终点的时候，另一个一定在中间，公式S=tv，t相同，v1 = 2*v2，那么路程也是两倍

AC代码

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
       if(!head) return NULL;
       ListNode *fast, *slow;
       fast = head;
       slow = head;
       while(fast->next)
       {
           fast = fast->next;
           if(fast->next) fast = fast->next;//fast走两步
           slow = slow->next;//slow走一步
       }
       return slow;
    }
};

题目四：环形链表

题源力扣141.点击跳转力扣

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递。仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。
在这里插入图片描述

思路

暴力法
遍历所有节点，每次遍历到一个节点时，判断该节点此前是否被访问过。

具体地，使用哈希表来存储所有已经访问过的节点。每次到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中。重复这一过程，直到遍历完整个链表即可。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> h;//保存访问过的节点
        while (head != nullptr) {
            if (h.count(head)) {//如果当前访问节点在h中，则有换
                return true;
            }
            h.insert(head);//将当前节点放入h
            head = head->next;
        }
        return false;
    }
};

暴力法也能AC

优化
快慢指针做，一个人快一个人慢，如果有圈，两个人必然相遇，一个人跑两圈，第二个人跑一圈，会在起始位置相遇

AC代码

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL || head->next == NULL) return false;
        ListNode *fast, *slow;
        slow = head;
        fast = head->next;
        while(slow != fast){
            if(fast == NULL || fast->next == NULL) return false;
            fast = fast->next->next;
            slow = slow->next;
        }
        return true;
    }
};

题目五：反转字符串中的元音字符

题源力扣345.点击跳转力扣

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。
元音字母包括 ‘a’、‘e’、‘i’、‘o’、‘u’，且可能以大小写两种形式出现不止一次。
在这里插入图片描述

思路

双指针法：
定义指针i, j, 初始化时指针i = 0, j = s.length() - 1;
从指针i开始从左到右遍历以找到第一个元音字符，从指针j开始从右到左遍历以找到第一个元音字符;
交换指针i与指针j锁指向的元音字符即可;
指针i和指针j在遍历过程中要注意数组越界情况。

AC代码

class Solution {
public:
    bool isVowel(char c){
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c =='A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
    }
    string reverseVowels(string s) {
        int i = 0;
        int j = s.size() - 1;
        while(i < j){
            if(!isVowel(s[i])){
                i ++;
                continue;
            }
            if(!isVowel(s[j])){
                j --;
                continue;
            }
            swap(s[i ++], s[j --]);

        }
        return s;
    }
};

题目六：最长连续不重复子序列

题源acwing799点击跳转acwing

给定一个长度为 n 的整数序列，请找出最长的不包含重复的数的连续区间，输出它的长度。
在这里插入图片描述

思路

遍历数组a中的每一个元素 a[i]，对于每一个 i ，找到j使得双指针 [j，i] 维护的是以a[i]结尾的最长不重复子序列，长度为 i - j + 1，将这一长度与r的较大者更新给r。
对于每一个 i ，如何确定 j 的位置：由于[j，i - 1]是前一步得到的最长连续不重复子序列，所以如果[j，i]中有重复元素，一定是a[i]，因此右移 j 一直到 a[i] 不重复为止，（由于[j, i - 1]已经是前一步的最优解，此时j只可能右移以剔除重复元素a[i]，不可能左移增加元素，因此，j具有“单调性”、本题可用双指针降低复杂度）。
用数组 s 记录子序列 a[j ~ i] 中各元素出现次数，遍历过程中对于每一个 i 有四步操作：cin元素a[i] -> 将a[i]出现次数s[a[i]]加1 -> 若a[i]重复则右移j（s[a[j]]要减1） -> 确定j及更新当前长度i - j + 1给r。

细节：当a[i]重复时，先把a[j]次数减1，再右移j。

AC代码

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int s[N];
int main(){
    int n;
    int r = 0;
    cin >> n;
    for(int i = 0, j = 0; i < n; i ++){
        cin >> a[i];
        s[a[i]] ++;//记录个数
        while(s[a[i]] > 1){
            -- s[a[j ++]];
        }
        r = max(r, i - j + 1);
    }
    cout << r;
}

题目七：判断子序列

在这里插入图片描述

思路

双指针算法
这题能扩展一种动态规划算法

j 指针用来扫描整个b数组，i 指针用来扫描a数组。若发现a[i] == b[j]，则让 i 指针后移一位。
整个过程中，j 指针不断后移，而i指针只有当匹配成功时才后移一位，若最后若 i == n，则说明匹配成功。

动态规划
bool dp[i][j] = true 表示a数组0 ~ i的序列是b数组0 ~ j序列的子序列
递推公式：
if(a[i - 1] == b[j - 1]) dp[i][j] = dp[i - 1][j - 1]
else dp[i][j] = dp[i][j - 1]，i是不能减的，无论无何都要确保a数组的所有元素都在b数组中，所以只能b退一步去比较，

AC代码

//双指针
#include<iostream>
using namespace std;
const int N=1e5+10;
int a[N],b[N];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 0;i < n; i++) scanf("%d",&a[i]);
    for(int j = 0;j < m; j++) scanf("%d",&b[j]);

    int i = 0;
    for(int j = 0;j < m; j++)
    {
        if(i < n&&a[i] == b[j])  i++;
    }
    if(i == n) puts("true");
    else puts("false");
    return 0;
}

//动态规划
class Solution {
public:
    bool isSubsequence(string s, string t) {
        int lens = s.size();
        int lent = t.size();
        vector<vector<bool>> dp(lens + 1, vector<bool>(lent + 1, false));
        for(int i = 0; i <= lent; i ++) dp[0][i] = true;
        for(int i = 1; i <= lens; i ++){
            for(int j = 1; j <= lent; j ++){
                if(s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] = dp[i][j - 1];
            }
        }
        return dp[lens][lent];
    }
};