欢迎拜访 ：雾里看山-CSDN博客
本篇主题 ：算法思想之双指针二)
发布时间 ：2025.4.5
隶属专栏 ：算法
目录
双指针算法介绍
常见的双指针有两种形式，一种是对撞指针，一种是快慢指针。
对撞指针：
⼀般⽤于顺序结构中，也称左右指针。
- 对撞指针从两端向中间移动。一个指针从最左端开始，另一个从最右端开始，然后逐渐往中间逼近。
- 对撞指针的终止条件一般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：
left == right（两个指针指向同一个位置）left > right（两个指针错开）
快慢指针：
又称为龟兔赛跑算法，其基本思想就是使用两个移动速度不同的指针在数组或链表等序列结构上移动 。
这种方法对于处理环形链表或数组非常有用。
其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使用快慢指针的思想。
快慢指针的实现方式有很多种，最常用的⼀种就是：
- 在一次循环中，每次让慢的指针向后移动一位，而快的指针往后移动两位，实现一快一慢。
例题
有效三角形的个数
题目链接
题目描述
给定一个包含非负整数的数组 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提示:
1 <= nums.length <= 10000 <= nums[i] <= 1000
算法思路
判断三角形的优化：
- 如果能构成三角形，需要满足任意两边之和要大于第三边。但是实际上只需让较小的两条边之和大于第三边即可。
- 因此我们可以先将原数组排序，然后从小到大枚举三元组，一方面省去枚举的数量，另一方面方便判断是否能构成三角形。
我们可以固定一个最长边 ，然后在比这条边小的有序数组中找出一个二元组，使这个二元组之和大于这个最长边。由于数组是有序的，我们可以利用对撞指针来优化。
设最长边枚举到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++进入下轮循环
- 说明
代码实现
cpp
class Solution {
public:
int triangleNumber(vector<int>& nums) {
sort(nums.begin(), nums.end());
int res = 0, n = nums.size();
for(int i = n-1; i > 1; i--)
{
for(int left = 0, right = i-1; left < right; )
{
if(nums[left]+nums[right] > nums[i])
{
res += right - left;
right--;
}
else
{
left++;
}
}
}
return res;
}
};
查找总价格为目标值的两个商品
题目链接
题目描述
购物车内的商品价格按照升序记录于数组
price。请在购物车中找到两个商品的价格总和刚好是target。若存在多种情况，返回任一结果即可。示例 1：
输入 ：
price = [3, 9, 12, 15],target = 18
输出 ：[3,15]或者[15,3]示例 2：
输入 ：
price = [8, 21, 27, 34, 52, 66],target = 61
输出 ：[27,34]或者[34,27]提示：
1 <= price.length <= 10^51 <= price[i] <= 10^61 <= target <= 2*10^6
算法思路
注意到本题是升序的数组，因此可以用对撞指针优化时间复杂度。
初始化 left ， right 分别指向数组的左右两端（这里不是我们理解的指针，而是数组的下标）
当 left < right 的时候，一直循环
- i. 当
nums[left] + nums[right] == target时，说明找到结果，记录结果，并且返回； - ii. 当
nums[left] + nums[right] < target时：- 对于
nums[left]而言，此时nums[right]相当于是nums[left]能碰到的最大值（别忘了，这里是升序数组哈~）。如果此时不符合要求，说明在这个数组里面，没有别的数符合nums[left]的要求了（最大的数都满足不了你，你已经没救了）。
因此，我们可以大胆舍去这个数，让left++，去比较下一组数据； - 那对于
nums[right]而言，由于此时两数之和是小于目标值的，nums[right]还可以选择比nums[left]大的值继续努力达到目标值，因此right指针我们按兵不动；
- 对于
- iii. 当
nums[left] + nums[right] > target时，同理我们可以舍去
nums[right]（最小的数都满足不了你，你也没救了）。让right--，继续比较下一组数据，而left指针不变（因为他还是可以去匹配比nums[right]更小的数的）。
代码实现
cpp
class Solution {
public:
vector<int> twoSum(vector<int>& price, int target) {
for(int left = 0, right = price.size() - 1; left < right;)
{
if(price[left]+price[right] > target)
right--;
else if(price[left]+price[right] < target)
left++;
else
return {price[left], price[right]};
}
// 随便写的，为了照顾编译器
return {-4941, -1};
}
};
三数之和
题目链接
题目描述
给你一个整数数组
nums，判断是否存在三元组[nums[i], nums[j], nums[k]]满足i != j、i != k且j != k，同时还满足nums[i] + nums[j] + nums[k] == 0。请你返回所有和为0且不重复的三元组。
注意 ：答案中不可以包含重复的三元组。
示例 1：输入 ：
nums = [-1,0,1,2,-1,-4]
输出 ：[[-1,-1,2],[-1,0,1]]
解释 ：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。不同的三元组是
[-1,0,1]和[-1,-1,2]。注意，输出的顺序和三元组的顺序并不重要。
示例 2：
输入 ：
nums = [0,1,1]
输出 ：[]
解释 ：唯一可能的三元组和不为0。示例 3：
输入 ：
nums = [0,0,0]
输出 ：[[0,0,0]]
解释 ：唯一可能的三元组和为0。提示：
3 <= nums.length <= 3000-105 <= nums[i] <= 105
算法思路
本题与两数之和类似，是非常经典的面试题。
与两数之和稍微不同的是，题目中要求找到所有不重复 的三元组。那我们可以利用在两数之和
那里用的双指针思想，来对我们的暴力枚举做优化：
- i. 先排序；
- ii. 然后固定一个数 a ：
- iii. 在这个数后面的区间内，使用双指针算法快速找到两个数之和等于 -a 即可。
但是要注意的是，这道题里面需要有去重操作~
- i. 找到一个结果之后， left 和 right 指针要跳过重复的元素；
- ii. 当使用完一次双指针算法之后，固定的 a 也要跳过重复的元素
代码实现
cpp
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<vector<int>> res;
int n = nums.size();
for(int i = 0; i < n; )
{
if(nums[i] > 0)
break;
int left = i+1, right = n - 1, target = -nums[i];
while(left < right)
{
if(nums[left]+nums[right] > target)
right--;
else if(nums[left]+nums[right] < target)
left++;
else
{
res.push_back({nums[i], nums[left],nums[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 res;
}
};
四数之和
题目链接
题目描述
给你一个由
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
算法思路
- 依次固定⼀个数
a； - 在这个数
a的后面区间上，利用三数之和 找到三个数，使这三个数的和等于target - a即可。
代码实现
cpp
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> res;
sort(nums.begin(), nums.end());
int n = nums.size();
for(int i = 0; i < n; )// 确定第一个数
{
for(int j = i+1; j < n; )
{
int left = j+1, right = n - 1;
long long aim = (long long)target - nums[i] - nums[j];
while(left < right)
{
long long sum = nums[left]+nums[right];
if(sum > aim)
right--;
else if(sum < aim)
left++;
else
{
res.push_back({nums[i], nums[j], nums[left],nums[right]});
left++, right--;
// 进行去重操作
while(left< right && nums[left]==nums[left-1]) left++;
while(left< right && nums[right]==nums[right+1]) right--;
}
}
j++;
// j 去重
while(j < n && nums[j]==nums[j-1]) j++;
}
i++;
// i 去重
while(i < n && nums[i]==nums[i-1]) i++;
}
return res;
}
};
⚠️ 写在最后：以上内容是我在学习以后得一些总结和概括，如有错误或者需要补充的地方欢迎各位大佬评论或者私信我交流！！！