【LeetCode】双指针题总结（持续更新）
文章目录
- 27. 移除元素（经典）
- 844. 比较含退格的字符串（与上一题同理）
- 11. 盛最多水的容器（双指针）
- 15. 三数之和（排序+双指针）
- 18. 四数之和（排序+双指针）
- 19. 删除链表的倒数第 N 个结点（双指针）
- 142. 环形链表 II（双指针）
- 977. 有序数组的平方（左右双指针）
27. 移除元素（经典）
27. 移除元素
思路和动图可以看这里
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
//i是快指针 j是慢指针
int j=0;
for(int i=0;i<nums.size();i++){
if(nums[i]!=val){
nums[j]=nums[i];
j++;
}
}
return j;
}
};
844. 比较含退格的字符串（与上一题同理）
844. 比较含退格的字符串
要倒着覆盖。
注意abc和abcc的情况，两个串要同时结束才能true。
class Solution {
public:
bool backspaceCompare(string s, string t) {
int num1=change(s);
int num2=change(t);
int i,j;
for(i=num1,j=num2;i<s.size()&&j<t.size();i++,j++){
if(s[i]!=t[j]) return false;
}
if(i==s.size()&&j==t.size()) return true;
else return false;
}
int change(string &s){
//i 快 j 慢
int num=0;int j=s.size()-1;
for(int i=s.size()-1;i>=0;i--){
if(s[i]=='#'){
num++;
}else{
if(num) num--;
else s[j--]=s[i];
}
}
return j+1;//这里要注意
}
};
11. 盛最多水的容器（双指针）
原题
参考题解1
参考题解2
解法：
双指针ij，分别指向头和尾。小的那个往中间走，每次存最大值，直到i=j。
直观理解：每次不是i走就是j走，那么相对小的那个会拖后腿，就走它。
严谨证明：来自参考1
较好理解的证明：来自参考2
class Solution {
public:
int maxArea(vector<int>& height) {
//双指针 让小的走，因为小的拖后腿
int ans=0;
int i=0,j=height.size()-1;
while(i<j)
{
ans=max(ans,(j-i)*min(height[i],height[j]));
if(height[i]<height[j]) i++;
else j--;
}
return ans;
}
};
15. 三数之和（排序+双指针）
15. 三数之和
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(),nums.end());
vector<vector<int>>ans;
if(nums.size()<3) return ans;
for(int i=0;i<nums.size();i++)
{
if(i&&nums[i]==nums[i-1]) continue;
int ii=i+1,jj=nums.size()-1;
int last=0x3f3f3f3f;
while(ii<jj)
{
if(nums[ii]+nums[jj]<0-nums[i]) ii++;
else if(nums[ii]+nums[jj]>0-nums[i]) jj--;
else
{
if(last!=nums[ii])
{
ans.push_back(vector<int>{nums[i],nums[ii],nums[jj]});
last=nums[ii];
}
ii++,jj--;
}
}
}
return ans;
}
};
18. 四数之和（排序+双指针）
18. 四数之和
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
sort(nums.begin(),nums.end());
vector<vector<int>>ans;
for(int i=0;i<nums.size();i++)
{
long long lastt=0x3f3f3f3f;
if((i&&nums[i]!=nums[i-1])||!i)
for(int j=i+1;j<nums.size();j++)
{
int ii=j+1,jj=nums.size()-1;
//防溢出
long long temp=nums[i]+nums[j];
//去重
if(temp==lastt) continue;
else lastt=temp;
long long need=target-temp;
int last=0x3f3f3f3f;
while(ii<jj)
{
long long tempp=nums[ii]+nums[jj];
if(tempp>need) jj--;
else if(tempp<need) ii++;
else
{
//里层循环的去重
if(last==0x3f3f3f3f||last!=nums[ii])
{
ans.push_back(vector<int>{nums[i],nums[j],nums[ii],nums[jj]});
last=nums[ii];
}
ii++,jj--;
}
}
}
}
return ans;
}
};
19. 删除链表的倒数第 N 个结点（双指针）
19. 删除链表的倒数第 N 个结点
双指针。
假设链表长度为n，要删除倒数第x个，有指针i（前指针），j（后指针）。
设链表从1开始，指针从0开始。
j先走x+1步，则j在第x+1的位置。
然后ij同时往前走，当j=NULL时，此时j的位置在n+1，则i走了(n+1)-(x+1)=n-x，i的下一个就是n-x+1，即要删除的结点。
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode *temp=new ListNode(0);
temp->next=head;
ListNode *a=temp;
ListNode *b=temp;
//后指针
for(int i=0;i<=n;i++) a=a->next;
//两个指针一起走 当后指针走到结尾时，前指针在要删除的结点的前面
while(a!=NULL)
{
a=a->next;
b=b->next;
}
//当走到这一步是 b在要删除的结点前面
b->next=b->next->next;
return temp->next;
}
};
142. 环形链表 II（双指针）
142. 环形链表 II
题解如下：环形链表 II（双指针法，清晰图解）
代码：
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode *slow=head,*fast=head;
while(fast&&fast->next)
{
fast=fast->next->next;
slow=slow->next;
//相遇
if(fast==slow)
{
fast=head;
while(fast!=slow)
{
slow=slow->next;
fast=fast->next;
}
return slow;
}
}
return NULL;
}
};
977. 有序数组的平方（左右双指针）
977. 有序数组的平方
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int i=0,j=nums.size()-1;
vector<int>ans;
int now=0;
while(i<=j){
if(nums[i]*nums[i]>nums[j]*nums[j]){
ans.push_back(nums[i]*nums[i]);
i++;
}
else{
ans.push_back(nums[j]*nums[j]);
j--;
}
}
reverse(ans.begin(),ans.end());
return ans;
}
};