【算法】--双指针

文章目录

双指针
例题
- 移动零
- 复写零
- 快乐数
- 盛⽔最多的容器
- 有效三角形的个数
- 和为 s 的两个数字
- 三数之和
- 四数之和

双指针

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

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

对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼近。
对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：
◦ left == right （两个指针指向同⼀个位置）
◦ left > right （两个指针错开）

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

这种方法对于处理环形链表或数组非常有用。
其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使用快慢指针的思想。
快慢指针的实现⽅式有很多种，最常⽤的⼀种就是：
• 在⼀次循环中，每次让慢的指针向后移动⼀位，而快的指针往后移动两位，实现⼀快⼀慢。

例题

移动零

在这里插入图片描述
思路：
在本题中，我们可以⽤⼀个 cur 指针来扫描整个数组，另⼀个 dest 指针⽤来记录⾮零数序列的最后⼀个位置。根据 cur 在扫描的过程中，遇到的不同情况，分类处理，实现数组的划分。在 cur 遍历期间，使 [0, dest] 的元素全部都是⾮零元素， [dest + 1, cur - 1] 的元素全是零。

算法流程：
a. 初始化 cur = 0 （⽤来遍历数组）， dest = -1 （指向⾮零元素序列的最后⼀个位置。
因为刚开始我们不知道最后⼀个⾮零元素在什么位置，因此初始化为 -1 ）
b. cur 依次往后遍历每个元素，遍历到的元素会有下⾯两种情况：

遇到的元素是 0 ， cur 直接 ++ 。因为我们的⽬标是让 [dest + 1, cur - 1] 内的元素全都是零，因此当 cur 遇到 0 的时候，直接 ++ ，就可以让 0 在 cur - 1 的位置上，从⽽在 [dest + 1, cur - 1] 内；
遇到的元素不是 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) {
for(int dest=-1,cur=0;cur<nums.size();cur++)
{
    if(nums[cur])swap(nums[++dest],nums[cur]);
}
return ;
    }
};

复写零

在这里插入图片描述
算法思路：
如果「从前向后」进⾏原地复写操作的话，由于 0 的出现会复写两次，导致没有复写的数「被覆盖掉」。因此我们选择「从后往前」的复写策略。
但是「从后向前」复写的时候，我们需要找到「最后⼀个复写的数」，因此我们的⼤体流程分两步：
1.先找到最后⼀个复写的数；
2.然后从后向前进行复写操作。

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

快乐数

快乐数
在这里插入图片描述
「快乐数」定义为：
对于⼀个正整数，每⼀次将该数替换为它每个位置上的数字的平⽅和。
然后重复这个过程直到这个数变为 1，也可能是⽆限循环但始终变不到 1 。
如果这个过程结果为 1 ，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。
在这里插入图片描述
可以看到，如果不是快乐数，最后会出现没有1 的循环，如果是快乐数，最后会出现1的循环

因此，变化的过程最终会⾛到⼀个圈⾥⾯，因此可以⽤「快慢指针」来解决。

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

class Solution
{
public:
 int bitSum(int n) // 返回 n 这个数每⼀位上的平⽅和{
 int sum = 0;
 while(n)
 {
 int t = n % 10;
 sum += t * t;
 n /= 10;
 }
 return sum;
 }
 bool isHappy(int n) 
 {
 int slow = n, fast = bitSum(n);
 while(slow != fast)
 {
 slow = bitSum(slow);
 fast = bitSum(bitSum(fast));
 }
 return slow == 1;
 }
};

盛⽔最多的容器

在这里插入图片描述

对撞指针
算法思路：
设两个指针 left ， right 分别指向容器的左右两个端点，此时容器的容积 :v = (right - left) * min( height[right], height[left]) 容器的左边界为 height[left] ，右边界为 height[right] 。
为了方便叙述，我们假设「左边边界」小于「右边边界」。
如果此时我们固定⼀个边界，改变另⼀个边界，水的容积会有如下变化形式：
◦ 容器的宽度一定变小。
◦ 由于左边界较小，决定了水面高度。如果改变左边界，新的水面高度不确定，但是⼀定不会超
过右边的柱子高度，因此容器的容积可能会增大。
◦ 如果改变右边界，无论右边界移动到哪⾥，新的⽔⾯的⾼度⼀定不会超过左边界，也就是不会
超过现在的水面高度，但是由于容器的宽度减小，因此容器的容积⼀定会变小的。
由此可见，左边界和其余边界的组合情况都可以舍去。所以我们可以 left++ 跳过这个边界，继续去判断下⼀个左右边界。

当我们不断重复上述过程，每次都可以舍去大量不必要的枚举过程，直到 left 与 right 相
遇。期间产生的所有的容积里面的最大值，就是最终答案。

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

有效三角形的个数

有效三角形的个数
在这里插入图片描述

算法思路：
先将数组排序。
我们可以固定⼀个「最长边」，然后在比这条边小的有序数组中找
出⼀个二元组，使这个二元组之和大于这个最长边。由于数组是有序的，我们可以利用「对撞指针」来优化。

设最长边枚举到 i 位置，区间 [left, right] 是 i 位置左边的区间（也就是比它小的区间）：
◦ 如果 nums[left] + nums[right] > nums[i] ：
▪ 说明 [left, right - 1] 区间上的所有元素均可以与 nums[right] 构成比nums[i] ⼤的⼆元组
▪ 满足条件的有 right - left 种
▪ 此时 right 位置的元素的所有情况相当于全部考虑完毕， right-- ，进⼊下⼀轮判断
◦ 如果 nums[left] + nums[right] <= nums[i] ：
▪ 说明 left 位置的元素是不可能与 [left + 1, right] 位置上的元素构成满足条件的⼆元组
▪ left 位置的元素可以舍去， left++ 进⼊下轮循环

class Solution
{
public:
 int triangleNumber(vector<int>& nums) 
 {
 // 1. 优化
 sort(nums.begin(), nums.end());
 // 2. 利⽤双指针解决问题
 int ret = 0, n = nums.size();
 for(int i = n - 1; i >= 2; i--) // 先固定最⼤的数
 {
 // 利⽤双指针快速统计符合要求的三元组的个数
 int left = 0, right = i - 1;
 while(left < right)
 {
 if(nums[left] + nums[right] > nums[i])
 {
 ret += right - left;
 right--;
 }
 else
 {
 left++;
 }
 }
 }
 return ret;
 }
};

和为 s 的两个数字

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

在这里插入图片描述
由于数组是升序的，我们可以用对撞指针，l，r指针分别从左右往中间走，如果和大于目标值，r指针向左走，小于则l指针向右走，等于时直接返回，当指针对撞时如果还没返回则退出循环。

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
int l=0,r=price.size()-1;
while(l<r)
{
    int sum=price[l]+price[r];
    if(sum>target)r--;
    else if(sum<target)l++;
    else return {price[l],price[r]};
}
return {-1,-1};
    }
};

三数之和

在这里插入图片描述
和上面两数之和类似，这里直接让两树和等于目标数＋第三数的相反数即可。
由于这里的数组不是有序的，可以先排一下序再用对撞指针解决问题。但是要注意的是，这道题里面需要有「去重」操作

class Solution
{
public:
 vector<vector<int>> threeSum(vector<int>& nums) 
 {
 vector<vector<int>> ret;
 // 1. 排序
 sort(nums.begin(), nums.end());
 // 2. 利⽤双指针解决问题
 int n = nums.size();
 for(int i = 0; i < n; ) // 固定数 a
 {
 if(nums[i] > 0) break; // ⼩优化
 int left = i + 1, right = n - 1, target = -nums[i];
 while(left < right)
 {
 int sum = nums[left] + nums[right];
 if(sum > target) right--;
 else if(sum < target) left++;
 else
 {
 ret.push_back({nums[i], nums[left], nums[right]});
 left++, right--;
 // 去重操作 left 和 right
 while(left < right && nums[left] == nums[left - 1]) left++;
 while(left < right && nums[right] == nums[right + 1]) 
right--;
}
 }
 // 去重 i 
 i++;
 while(i < n && nums[i] == nums[i - 1]) i++;
 }
 return ret;
 }
};

四数之和

四数之和
在这里插入图片描述
与上题类似，固定一个数，转到三数之和，注意去重。

class Solution
{
public:
 vector<vector<int>> fourSum(vector<int>& nums, int target) 
 {
 vector<vector<int>> ret;
 // 1. 排序
 sort(nums.begin(), nums.end());
 // 2. 利⽤双指针解决问题
 int n = nums.size();
 for(int i = 0; i < n; ) // 固定数 a
 {
 // 利⽤ 三数之和
 for(int j = i + 1; j < n; ) // 固定数 b
 {
 // 双指针
 int left = j + 1, right = n - 1;
 long long aim = (long long)target - nums[i] - nums[j];
 while(left < right)
 {
 int sum = nums[left] + nums[right];
 if(sum < aim) left++;
 else if(sum > aim) right--;
 else
 {
 ret.push_back({nums[i], nums[j], nums[left++], 
nums[right--]});
 // 去重⼀
 while(left < right && nums[left] == nums[left - 1]) 
left++;
 while(left < right && nums[right] == nums[right + 1]) 
right--;
 }
 }
 // 去重⼆
 j++;
 while(j < n && nums[j] == nums[j - 1]) j++;
 }
 // 去重三
 i++;
 while(i < n && nums[i] == nums[i - 1]) i++;
 }
 return ret;
 }
};