【优选算法】详解双指针问题（图文结合版）

//leetcode详细图解与方法总结可见文末~

目录

引言：双指针

1. 移动零（easy）

题目：

算法思路：

代码：

1089.复写0（易错题）

题目：

代码：

202.快乐数

题目：

代码：

11.盛水最多的容器

题目：

代码：

611.有效三角形的个数

题目：

代码：

sum与图解:

---

引言：双指针

常⻅的双指针有两种形式，⼀种是对撞指针，⼀种是左右指针。

对撞指针：⼀般⽤于顺序结构中，也称左右指针。

• 对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼 近。

• 对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循 环），也就是：

•  left == right （两个指针指向同⼀个位置）
•  left > right （两个指针错开）

 快慢指针：⼜称为⻳兔赛跑算法，其基本思想就是使⽤两个移动速度不同的指针在数组或链表等序列 结构上移动。

这种⽅法对于处理环形链表或数组⾮常有⽤。

其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使⽤快 慢指针的思想。

快慢指针的实现⽅式有很多种，最常⽤的⼀种就是：

• 在⼀次循环中，每次让慢的指针向后移动⼀位，⽽快的指针往后移动两位，实现⼀快⼀慢。

1. 移动零（easy）

「数组分两块」是⾮常常⻅的⼀种题型，主要就是根据⼀种划分⽅式，将数组的内容分成左右两部 分。这种类型的题，⼀般就是使⽤「双指针」来解决。

题目：

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:

输入: nums = [0]
输出: [0]

算法思路：

在本题中，我们可以⽤⼀个cur 指针来扫描整个数组，

另⼀个dest 指针⽤来记录⾮零数序列 的最后⼀个位置。

根据 cur 在扫描的过程中，遇到的不同情况，分类处理，实现数组的划分。 在 cur 遍历期间，使[0, dest] 的元素全部都是⾮零元素， [dest + 1, cur - 1] 的 元素全是零。

算法流程：

a. 初始化cur = 0 （⽤来遍历数组），dest = -1 （指向⾮零元素序列的最后⼀个位置。 因为刚开始我们不知道最后⼀个⾮零元素在什么位置，因此初始化为-1 ）

 b. cur 依次往后遍历每个元素，遍历到的元素会有下⾯两种情况：

i. 遇到的元素是0 ， cur 直接 ++ 。因为我们的⽬标是让[dest + 1, cur - 1] 内 的元素全都是零，因此当cur 遇到0 的时候，直接 ++ ，就可以让0 在cur - 1 的位置上，从⽽在[dest + 1, cur - 1] 内；

 ii. 遇到的元素不是0 ， dest++ ，并且交换cur 位置和dest 位置的元素，之后让 cur++ ，扫描下⼀个元素。

• • 因为 dest 指向的位置是⾮零元素区间的最后⼀个位置，如果扫描到⼀个新的⾮零元 素，那么它的位置应该在dest + 1 的位置上，因此dest 先⾃增1 ；
•  • dest++ 之后，指向的元素就是0 元素（因为⾮零元素区间末尾的后⼀个元素就是 0 ），因此可以交换到cur 所处的位置上，实现[0, dest] 的元素全部都是⾮零 元素， [dest + 1, cur - 1] 的元素全是零。

代码：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        // 双指针
        int n = nums.size();
        int dest = -1, cur = 0;
        for (cur = 0; cur < n; cur++) {
            // 不是0的时候进行交换
            if (nums[cur] != 0) {//想清楚是交换数
                swap(nums[dest + 1],nums[cur]); // 将dest的下一位永远换为非零
                dest++;              // 永远指向非0
            }
        }
    }

};

1089.复写0（易错题）

题目：

给你一个长度固定的整数数组 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]
示例 2：

输入：arr = [1,2,3]
输出：[1,2,3]
解释：调用函数后，输入的数组将被修改为：[1,2,3]

代码：

class Solution
{
public:
	void duplicateZeros(vector<int>& arr)
	{
		// 1. 先找到最后⼀个数 
		int cur = 0, dest = -1, n = arr.size();
		while (cur < n)
		{
			if (arr[cur]) dest++;
			else dest += 2;
			if (dest >= n - 1) break;
			cur++;
		}
		// 2. 处理⼀下边界情况 
		if (dest == n)
		{
			arr[n - 1] = 0;
			cur--; dest -= 2;
		}
		// 3. 从后向前完成复写操作 
		while (cur >= 0)
		{
			if (arr[cur]) arr[dest--] = arr[cur--];
			else
			{
				arr[dest--] = 0;
				arr[dest--] = 0;
				 cur--;
			}
		}
	}
};

202.快乐数

题目：

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例 2：

输入：n = 2
输出：false

代码：

class Solution {
public:
//快乐算法的形成
    int happy(int n)
    {
        long long sum=0;
        while(n)
        {
            int a=n%10;
            sum+=a*a;
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow=n,fast=happy(n);//用快慢指针来判断循环
        //happy数1.一定是循环的
        while(slow!=fast)
        {
            //不相等就一直后移
            slow=happy(slow);
            fast=happy(happy(fast));//不断处理自身
        }
        //2.判断循环的值，是不是1
        return slow==1;
    }
};

11.盛水最多的容器

题目：

给定一个长度为 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。

示例 2：

输入：height = [1,1]
输出：1

代码：

class Solution {
public:
    int maxArea(vector<int>& height) {
        //对撞指针
        int n=height.size();
        int right=n-1,left=0,ret=0;
        while(left!=right)
        {
            int volume=min(height[right],height[left])*(right-left);
            ret=max(ret,volume);
            if(height[right]<height[left])
            right--;
            else left++;
        }
        return ret;

    }
};

611.有效三角形的个数

题目：

给定一个包含非负整数的数组 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

代码：

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        //sort是默认升序的
        sort(nums.begin(),nums.end());
        int n=nums.size();
        int ret=0,c=n-1;//要记得初始化
        //最大数和对撞指针的循环嵌套
        for(c;c>=2;c--)
        {
            int left=0,right=c-1;//每轮c都要重新定义
            while(left!=right)
            {
                //对三角形进行判断
                if(nums[left]+nums[right]>nums[c])
                {//对两个指针的数组移动条件
                    ret+=right-left;
                    right--;
                }
                else
                left++;
            }

        }
        return ret;

    }
};

sum与图解: