双指针（上）

前言

双指针

---

一、双指针是什么？

不一定是指针，只是一种称呼 一般用数组下标充当指针

类型：1对撞指针  具有单调性

           2快慢指针 往往带循环

二、例题

1.移动零

用一个des变量表示下标，表示des前面的值已经处理好 （从开头的数到des对应的数结尾 都没有0）用cur变量表示正在处理的数据

即【0，des】区间内的值全不为零，【des+1，cur-1】全为零 【cur，size-1】为待处理的元素

1 cur一开始指向0位置 ，des为-1

2当cur位置为0，不用处理，cur直接++

3当cur位置为1，需要处理，des++，交换des与cur对应的值 cur++

4循环结束条件为cur>=数组大小

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int cur=0;
        int des=-1;
        while(cur<nums.size())
        {
            if(nums[cur]==0)
                cur++;
            else
                swap(nums[++des],nums[cur++]);
        }
    }
};

2复写零

如果对空间复杂度没有要求，那么和第一道类似

cur=0，cur处理一个数组   des=-1  des对应处理另一个相同数组

如果cur对应的值为0，des++，des对应的值赋值0，des++，des赋值0,cur++。

cur对应的值不为0，des++，des对应的值赋值cur对应的值,cur++。

但这题对空间有要求，其实只要按上面的方法找出cur最后处于什么位置

再倒过来使用双指针就行（正着来des指针会将cur未读取到的值覆盖掉）

，这与第一题不同，第一题是减少元素，所以可以正着使用双指针

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {
        int cur=0;
        int des=-1;
        int flat=0;
        while(cur<arr.size()||des<arr.size())
        {
            if(arr[cur]!=0)
            {
                des++;
                if(des==arr.size()-1)
                    break;
                cur++;
            }
            else
            {
                des++;
                if(des==arr.size()-1)
                {
                    flat=1;
                    break;
                }
                des++;
                if(des==arr.size()-1)
                    break;
                    cur++;
            }
        }
        des++;
        while(cur>=0)
        {
            if(arr[cur]!=0||flat==1)
            {
                des--;
                arr[des]=arr[cur];
                cur--;
                if(flat==1)
                    flat=0;
            }
            else 
            {
                des--;
                arr[des]=arr[cur];
                des--;
                arr[des]=arr[cur];
                cur--;
            }
        }
    }
};

3快乐数

这题出现了一个数在经历了一个处理后变为了另一个是数，在一定的操作次数后

这个数会进入循环，一种是1，1，1，1....一种是无限循环但不是1

像这种题 （类似于找带环链表）都可以用快慢指针来解决

具体原理就是用快慢指针 快指针执行两步，慢指针执行一步，两个指针一定会在环内相遇

注意 fast 与slow初始化时要用不同的值，即fast的值时slow经历了一次操作后得到的值

否则进入不了循环

class Solution {
public:
    int bitSquareSum(int n)
    {
        int sum=0;
        while(n)
        {
            sum+=(n%10)*(n%10);
            n/=10;
        }
        return sum;
    }
    bool isHappy(int n) {
       int fast=bitSquareSum(bitSquareSum(n));
       int slow=bitSquareSum(n);
       while(fast!=slow)
       {
            fast=bitSquareSum(bitSquareSum(fast));
            slow=bitSquareSum(slow);
       }
        if(fast==1)
            return true;
        else
            return false;
        
    }
};

 4盛最多水的容器

对撞双指针 v具有“单调性”

即

v=（right-left)*min(height[fast],height[slow]);

一开始就然left=0，right=size-1 那么体积的长度（right-left)就是最大值，对应的高度为height[fast],height[slow]，记录下此时的v ，记为v1。如果后续要让v更大，那么高度只能增加，

因为长度一定减小（要不就是left++，要不就是right--），对于让min(height[fast],height[slow]变小的操作就不用考虑了，即height[left]>height[right] right--；height[left]<=height[right]

left++;然后再计算体积 记为v2 ，同样操作得到v3，v4等等，然后返回最大的v

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

5有效三角形的个数

1思路 ：先暴力找思路，一开始数组不是有序的，用三层for循环 每一组数都要两两相加大于第三个数，为O(3*n^3)

再对数组排序后，三层for循环，只需要前两个数与第三个数比较即可，

继续优化，三角形判断方法：最小的两个值相加小于第三个就行，那么

最大的数从后往前遍历为第一层循环，次大的数也从后往前遍历，最小的数从前往后遍历，为第二层循环固定次大的数，如果最小加次大小于最大，最小++，直到找到符合的，此时right-left则为固定最大和次大所能构成的三角形个数，注意这里left不再置0，因为下一次right--，right对应的值一定比之前的小，那么left对应的值如果是left-1对应的值，但是这个值对应的right相加是更小的。

这样就left 和right形成了对撞指针，时间复杂度降到了o(n^2)

int triangleNumber(vector<int>& n) {
        sort(n.begin(),n.end());
        int sum=0;
        for(int i=n.size()-1;i>=2;i--)
        {
            int left=0;
            int right=i-1;
            while(left!=right)
            {
                if(n[left]+n[right]>n[i])
                {
                    sum+=right-left;
                    right--;
                }
                else
                    left++;
            }
        }
        return sum;

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

此题与第四题差不多 

return {price[left],price[right]};//隐式转化

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target) {
        int left=0;
        int right=price.size()-1;
        while(price[left]+price[right]!=target)
        {
            if(price[left]+price[right]<target)
                left++;
            else
                right--;
        }
        //vector<int>ret(2);
        //ret[0]=price[left],ret[1]=price[right];
        //return ret;
    }
    return {price[left],price[right]};//隐式转化
};