学习使用双指针

​

​

🔥个人主页：guoguoqiang. 🔥专栏：leetcode刷题

双指针，有时候是快慢指针的方式来进行题目，
有时候是同向双指针来完成题目（这个也叫滑动窗口），
有时候是通过两个指针一个在头一个在尾，对撞双指针。

283.移动零

这个题目的就是将非零都在前面，而0都去后面。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        for(int cur=0,dest=-1;cur<nums.size();cur++)
            if(nums[cur])//如果这个数不为0则交换
                swap(nums[++dest],nums[cur]);
    }
};

​

1089.复写0

就地修改
先设置两个变量cur和dest，n为数组个数
先找到最后复写的位置
根据题目复写规则，如果cur对应的元素为0则dest往后走两步，反之则走一步。然后还需要注意dest是否会越界。
如果dest==n则越界了，需要将dest-1位置置为0，然后dest-=2，cur–，cur最后对应的位置即为最后复写的位置。
然后从cur位置向前写，因为从前往后写会造成数据覆盖然后可能会全为0。

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {
        int cur=0,dest=-1,n=arr.size();
        while(cur<n){//找最后复写的位置
            if(arr[cur]) dest++;
            else dest+=2;
            if(dest>=n-1) break;
            cur++;
        }
        if(dest==n){//处理越界情况
            arr[n-1]=0;
            dest-=2;
            cur--;
        }
        while(cur>=0){//从后往前复写，如果不为0则覆盖后都往前移动1，如果为0则将前两个都置为0，然后dest-=2，cur也向前继续判断
            if(arr[cur]) arr[dest--]=arr[cur--];
            else {
                arr[dest--]=0;
                arr[dest--]=0;
                cur--;
            }
        }
    }
};

202.快乐数

这个题就是可能会无限循环，就可以通过快慢双指针来做。

class Solution {
public:
    int bitsum(int n){//返回每一次各个数位上的平方和
        int sum=0;
        while(n>0){
        int m=n%10;
        sum+=m*m;
        n/=10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow=n,fast=bitsum(n);
        while(slow!=fast){//相遇则判断当前位置是否为1
            slow=bitsum(slow);
            fast=bitsum(bitsum(fast));
        }
        return slow==1;//如果为1则返回true，否则就为false；
    }
};

11.盛水最多的容器

方法一：暴力枚举

class Solution {
public:
int maxArea(vector<int>& height) {
int n = height.size();
int ret = 0;
// 两层 for 枚举出所有可能出现的情况
	for (int i = 0; i < n; i++) {
		for (int j = i + 1; j < n; j++) {
		// 计算容积，找出最⼤的那⼀个
		ret = max(ret, min(height[i], height[j]) * (j - i));
		}
	}
	return ret;
	}
};

方法二： 我们可以想象一下 如果v=h*d d越往回靠越小，然后已知d减小高度减小更会小，所以就需要向找h增大的方向靠。
利用对撞指针来完成

class Solution {
public:
    int maxArea(vector<int>& height) {
        int left=0,right=height.size()-1,ret=0;//定义两个指针，一左一右
        while(left<right){
            int v=min(height[right],height[left])*(right-left);
            ret=max(v,ret);//保证ret为最大体积
            if(height[left]<height[right]) left++;//保留高度高的
            else right--;
        }
        return ret;
    }
};

611.有效三角形的个数

三角形 两边之和大于第三边
第一种方法：先排序+暴力枚举（会超时）
三个for循环遍历所有可能，求出结果

class Solution {
public:
int triangleNumber(vector<int>& nums) {
// 1. 排序
sort(nums.begin(), nums.end());
int n = nums.size(), ret = 0;
// 2. 从⼩到⼤枚举所有的三元组
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
// 当最⼩的两个边之和⼤于第三边的时候，统计答案
if (nums[i] + nums[j] > nums[k])
ret++;
}
}
}
return ret;
}
}

方法二： 排序+对撞指针
最小的一个边加上一个边比最大的那个边大，则left后面right前面的那部分加上right对应的，一定比那个边大，可以构成三角形。

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        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对应的数增大
                    left++;
                }
            }
        }
        return ret;
    }
};

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

方法一：暴力枚举

class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int n = nums.size();
for (int i = 0; i < n; i++) { // 第⼀层循环从前往后列举第⼀个数
for (int j = i + 1; j < n; j++) { // 第⼆层循环从 i 位置之后列举第⼆个数
if (nums[i] + nums[j] == target) // 两个数的和等于⽬标值，说明我们已经找到结果了
return {nums[i], nums[j]};
}
}
return {-1, -1};
}
};

方法二：双指针-对撞指针
（由题目可以看出本题是升序的数组）就可以使用对撞指针来解决。

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
        int left=0,right=price.size()-1;//双指针，都是下标
        while(left<right){
            if(price[left]+price[right]<target){//如果小于目标值就++left增大相加的和
                left++;
            }
            else if(price[left]+price[right]>target){//如果大于目标值就--right减小相加的和
                right--;
            }
            else {
                return {price[left],price[right]};//如果相等就返回
            }
        }
        return {-1,-1};
    }
};

15.三数之和

根据前面做过的二数之和，可以浅浅的复用一下。
方法： 排序+对撞指针
先排序，然后固定一个数，接着就是二数之和的思想，不同的是这个题需要去重。（去重时需要注意）

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ret;
        sort(nums.begin(),nums.end());
        int n=nums.size();
        for(int i=0;i<=n-3;){//固定一个数
       		 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--;
                    while(left<right && nums[left]==nums[left-1]) left++;//对left对应的元素判断去重
                    while(left<right && nums[right]==nums[right+1]) right--;//对right对应的元素判断去重
                }
            }
            i++;
            while(i<n && nums[i]==nums[i-1]) i++;//对i对应的元素判断去重
        }
        return ret;
    }
};

16.四数之和

方法：先排序然后固定一个数，将四数之和转换为三数之和，然后记得去重

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ret;
        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 tar=(long long)target-nums[i]-nums[j];//题目中有大数据需要开longlong类型
                while(left<right){
                    int sum=nums[left]+nums[right];
                    if(sum<tar) left++;
                    else if(sum>tar) right--;
                    else{
                        ret.push_back({nums[i],nums[j],nums[left],nums[right]});
                        left++;
                        right--;
                        while(left<right && nums[left]==nums[left-1]) left++;//对left对应的元素判断去重
                        while(left<right && nums[right]==nums[right+1]) right--;//对right对应的元素判断去重
                    }
                }
                j++;
                while(j<n && nums[j]==nums[j-1]) j++;//对j对应的元素判断去重
            }
            i++;
            while(i<n && nums[i]==nums[i-1]) i++;//对i对应的元素判断去重
        }
        return ret;
    }
};

本片内容到此结束，感谢大家观看！！！