【算法系列】双指针

1. 双指针算法概述

常⻅的双指针有两种形式，⼀种是对撞指针，⼀种是左右指针。
对撞指针：⼀般⽤于顺序结构中，也称左右指针。
• 对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼
近。
• 对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循
环），也就是：
◦ left == right （两个指针指向同⼀个位置）
◦ left > right （两个指针错开）
快慢指针：⼜称为⻳兔赛跑算法，其基本思想就是使⽤两个移动速度不同的指针在数组或链表等序列
结构上移动。
这种⽅法对于处理环形链表或数组⾮常有⽤。
其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使⽤快
慢指针的思想。
快慢指针的实现⽅式有很多种，最常⽤的⼀种就是：
• 在⼀次循环中，每次让慢的指针向后移动⼀位，⽽快的指针往后移动两位，实现⼀快⼀慢。

2 经典双指针算法题目分享

1. 复写零

1 . 题目链接：1089. 复写零
2 .题目描述：

给你⼀个⻓度固定的整数数组 arr ，请你将该数组中出现的每个零都复写⼀遍，并将其余的元素
向右平移。
注意：请不要在超过该数组⻓度的位置写⼊元素。请对输⼊的数组就地进⾏上述修改，不要从函数返回任何东西。
⽰例 1：
输⼊： arr = [1,0,2,3,0,4,5,0]
输出： [1,0,0,2,3,0,0,4]
解释：
调⽤函数后，输⼊的数组将被修改为： [1,0,0,2,3,0,0,4]

3 .思路实现

1. 首先利用双指针模拟复写过程来找到我们要复写的最后一个数:

• 定义一个dest指针为-1，一个cur指针为0，判断arr[cur]是不是0，是0dest走两步，不是0走一步，然后cur++直到dest指针大于或等于数组末尾
  如下图所示：
  2 .开始复写操作如果arr[cur]不是零arr[dest- -]=arr[cur- -]如果为零arr[dest- -] = 0,arr[dest- -]=0,cur- -,直到cur>=0循环结束
  3 . 注意处理特殊情况：
  如果复写的最后一个数是0会导致dest越界
  
  这种情况我们就把当前0直接进行复写也就是把数组最后一个数字变为0，cur- -，dest-=2；
  4. 代码实现

class Solution 
{
public:
    void duplicateZeros(vector<int>& arr) 
    {
        int dest = -1,cur = 0;
        int size = arr.size();
        //模拟找到倒着复写的第一个
       for(;cur<size;cur++)
       {
        if(arr[cur]==0) dest+=2;
        else dest+=1;
        if(dest>=size-1) break;
       }
       //处理cur指向0导致dest越界
       if(dest>=size)
       {
        arr[size-1] =0;
        dest-=2;
        cur--;
       }
       while(cur>=0)
       {
        if(arr[cur]) arr[dest--] = arr[cur--];
        else 
        {
            arr[dest--] =0;
            arr[dest--] = 0;
            cur--;
        }
       }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

---

2. 快乐数（medium）

1 .题目链接：202. 快乐数
2 . 题目描述：

编写⼀个算法来判断⼀个数 n 是不是快乐数。
「快乐数」 定义为：
◦ 对于⼀个正整数，每⼀次将该数替换为它每个位置上的数字的平⽅和。
◦ 然后重复这个过程直到这个数变为 1，也可能是⽆限循环但始终变不到 1 。
◦ 如果这个过程 结果为 1 ，那么这个数就是快乐数。
◦ 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
⽰例 1：
输⼊： n = 19
输出： true
解释：
19 -> 1 * 1 + 9 * 9 = 82
82 -> 8 * 8 + 2 * 2 = 68
68 -> 6 * 6 + 8 * 8 = 100
100 -> 1 * 1 + 0 * 0 + 0 * 0 = 1
⽰例 2：
输⼊： n = 2
输出： false
解释：（这⾥省去计算过程，只列出转换后的数）
2 -> 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4 -> 16
往后就不必再计算了，因为出现了重复的数字，最后结果肯定不会是 1

3 . 思路实现

根据上述的题⽬分析，我们可以知道，当重复执⾏ x 的时候，数据会陷⼊到⼀个「循环」之中。
⽽「快慢指针」有⼀个特性，就是在⼀个圆圈中，快指针总是会追上慢指针的，也就是说他们总会
相遇在⼀个位置上。如果相遇位置的值是 1 ，那么这个数⼀定是快乐数；如果相遇位置不是 1
的话，那么就不是快乐数。

4 . 代码实现：

class Solution
{
public:
   int sum(int n)
   {
    int ret =0;
    while(n)
    {
        int tem = n%10;
        ret += tem*tem;
        n/=10;
    }
    return ret;
   }
    bool isHappy(int n)
     {
        //由于鸽巢问题最后一定会循环
        int slow = n,fast = sum(n);
        while(slow!=fast)
        {
            slow = sum(slow);
            fast = sum(sum(fast));
        }
        if(slow==1) return true;
        else return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

---

3. 11. 盛最多水的容器

1 . 题目链接：11. 盛最多水的容器
2 . 题目描述：

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

4. 思路分析：

设两指针 i , j ，分别指向⽔槽板的最左端以及最右端，此时容器的宽度为 j - i 。由于
容器的⾼度由两板中的短板决定，因此可得容积公式 ： v = (j - i) * min( height[i], height[j])
便利时我们判断是否height[i]<height[j]，i++反之j–;因为我们往里面便利时宽度减小因此此时我们要更新高度。
5. 代码实现：

class Solution 
{
public:
    int maxArea(vector<int>& height) 
    {
        int i = 0,j = height.size()-1,ret = 0;
        while(i<j)
        {
            int v = min(height[i],height[j])*(j-i);
            ret = max(ret,v);
            if(height[i]<=height[j]) i++;
            else j--;
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4. 有效三⻆形的个数（medium）

1. 题目链接：有效三⻆形的个数
2. 题目描述：

给定⼀个包含⾮负整数的数组 nums ，返回其中可以组成三⻆形三条边的三元组个数。
⽰例 1:
输⼊: nums = [2,2,3,4]
输出: 3
解释:有效的组合是:
2,3,4 (使⽤第⼀个 2)
2,3,4 (使⽤第⼆个 2)
2,2,3
⽰例 2:
输⼊: nums = [4,2,3,4]
输出: 4
解释：
4,2,3
4,2,4
4,3,4
2,3,4

3. 算法思路：

• 首先我们把数组排为升序利用最小两边之和大于第三边来进行判断是否为三角形
• 每次固定一个最大边nums.size()-1(k)处的元素；定义i = 0；j = k-1；
• 判断nums[i]+nums[j]是否>nums[k]如果是则这个区间都可以构造三角形之后j–
• 反之i++;

4. 代码实现：

class Solution 
{
public:
    int triangleNumber(vector<int>& nums) 
    {
        //1.进行排序
        sort(nums.begin(),nums.end());
        int ret = 0;
        //2. 固定最大边
        for(int i = nums.size()-1;i>=2;i--)
        {
             int left = 0;int right = i-1;
            while(left<right)
            {
                if(nums[left]+nums[right]>nums[i])
                {
                    ret+=right-left;
                    right--;
                }
                else left++;
            }
            
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5. 四数之和

1. 题目链接：四数之和
2. 题目描述：

给你⼀个由 n 个整数组成的数组 nums ，和⼀个⽬标值 target 。请你找出并返回满⾜下述全部条件
且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素⼀⼀对应，则认为
两个四元组重复）：
◦ 0 <= a, b, c, d < n
◦ a、b、c 和 d 互不相同
◦ nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。
⽰例 1：
输⼊：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
比特就业课
⽰例 2：
输⼊：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]
提⽰：
1 <= nums.length <= 200
-109 <= nums[i] <= 109
-109 <= target <= 109

3. 算法思路：

先排序之后固定第一个数在固定第二个数接着用双指针算法去找符合要求的结果就可以了注意这里我们需要处理去重操作就是就是每次我们使用双指针找到一个结果时让左右指针移动到不与此时的元素重合的位置，同时我们固定的第二个数也应该避免重复，最后就是固定的第一个数也应该避免重复这样结果一定不会有重复的

4. 代码实现：

class Solution 
{
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) 
    {
        sort(nums.begin(),nums.end());
        int n = nums.size();vector<vector<int>> ret;
        //固定一个值
        for(int i = 0;i<n;)
        {
            int tem4 = nums[i];
            //固定第二个值
            for(int j = i+1;j<n;)
            {
                int tem3 = nums[j];
                int left = j+1,right =n-1;
               long long  int target1 = (long long int)target-(long long int)
               nums[i]-(long long int)nums[j];
                while(left<right)
                {
                    if(nums[left]+nums[right]==target1)
                {
                    ret.push_back({nums[i],nums[j],nums[left],nums[right]});
                    int tem1 =nums[left],tem2 = nums[right];
                    while(left<right&&nums[left]==tem1) left++;
                    while(left<right&&nums[right]==tem2) right--;
                }
                else if(nums[left]+nums[right]>target1) right--;
                else left++;
                }
                while(j<n&&nums[j]==tem3) j++;
            }
            while(i<n&&nums[i]==tem4) i++;
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37