【LeetCode热题100】双指针

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

题目分析：对于数组分块/数组划分的问题，我们可以使用双指针算法进行求解（这道题的“指针”是数组下标）。我们使用两个“指针”dst和cur，将数组划分为三个区间：[0,dst]已处理过且不为0的区间、[dst+1,cur-1]已处理过且为0的区间、[cur,n-1]待处理的区间。两个指针的作用：cur--从左往右扫描数组，遍历数组；dst--已处理的区间内，非零元素的最后一个位置。cur向后依次遍历，可能会有两种情况：1.cur指向的元素为0，cur++  2.cur指向的元素不为0，swap(nums[dst+1],nums[cur])，cur++，dst++。由于刚开始时没有已处理的区间，所以dst=-1，cur=0。

 

class Solution {
public:
    void duplicateZeros(vector<int>& arr) 
    {
        //1.找到要复写的最后一个数
        int cur = 0,dst = -1;
        while(cur < arr.size())
        {
            if(arr[cur] == 0) dst+=2;
            else dst++;
            if(dst >= arr.size()-1)
            {
                break;
            }
            cur++;
        }
        //处理一下边界情况：dst加了两下，加过了
        if(dst == arr.size())
        {
            arr[dst-1]=0 ;
            dst-=2;
            cur--;
        }
        //2.从后向前复写
        while(cur >= 0)
        {
            if(arr[cur] == 0)
            {
                arr[dst]=arr[dst-1]=0;
                dst -= 2;
                cur--;
            }
            else
            {
                arr[dst]=arr[cur];
                dst--;
                cur--;
            }
        }
    }
};

 题目分析：这道题是对数组元素进行操作，可以考虑双指针算法。整体思路就是先根据“异地”操作，然后优化成双指针下的“就地”操作。我们首先想到的是另外创建一个数组，进行异地操作，一个指针cur指向原数组，另一个指针dst指向新建数组，cur依次遍历每一个数，按照要求在新建数组进行复写。然而，这样的做法明显不符合“就地操作”的要求，因此，我们需要让cur和dst都指向原数组，如果它们都指向了起始位置，这样遇到复写0之后就会覆盖后面的元素，肯定会出问题。所以我们需要从后往前复写，dst需要指向数组最后一个元素，cur要指向最后一个“复写”的数，因此，我们总共有两步：1.先找到最后一个“复写”的数  2.“从后向前”完成复写操作。经过多次实践，可以通过如下方法找到最后一个复写的数：1）先判断cur位置的值 2）决定dest向后移动一步或者两步 3）判断一下dest是否已经结束 4）cur++  在开始之前，我们需要先让dst指向-1，cur指向0（因为最终dst指向最后一个要复写的位置，刚开始的时候并不知道最后一个位置在哪，因此设为-1），当这个循环退出时，cur指向了最后一个“复写”的数。此外，在找最后一个要复写的数的过程中，我们还可能因为cur最后一次指向0，dst需要加两次，跳到了arr的外面，即下标为n的位置，对于这种情况，我们需要单独处理一下，让arr[n-1]=0，然后dst回退两次，cur--即可。

class Solution {
public:
    int bitSum(int n)
    {
        int sum = 0;
        while(n)
        {
            int lastbit = n%10;
            sum += lastbit*lastbit;
            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;
    }
};

题目分析：给定一个正整数，按照题目给定的过程重复计算，会有两种结果：其一是这个数在某一次变成1，那么之后会一直循环1；第二种是这个数会在某个圈里无限循环，但是不是1。因此，一定会进入循环（鸽巢原理），我们可以通过判断当进入循环后，这个值是不是1来确定这个数是不是快乐数。

那么如何找到进入循环的某一个数呢？这个就需要用到快慢指针的思想：

（一）定义快慢指针

（二）慢指针每次向后移动一步，快指针每次向后移动两步

（三）判断相遇时候的值即可

class Solution {
public:
    int maxArea(vector<int>& height) 
    { 
        int max= 0;
        int i =0,j=height.size()-1;
        int v = 0;//体积
        while( i < j)
        {
            v = (j - i) * (height[i]<height[j]?height[i]:height[j]);
            if(v > max) max = v;
            if(height[i] < height[j]) 
                i++;
            else 
                j--;
        }

        return max;

    }
};

题目分析：第一种方法就是暴力求解，遍历每一个可能得组合，计算出它们的体积的最大值，但是这种方法是运行超时的，因此我们还要另辟蹊径。

第二种方法比较巧妙，我们先来看一个简单例子，如果数组是[6,2,5,4]，那我们先计算最外面两个数的组合：6和4，宽度是3，高度是max（6,4）=4，体积=3*4=12，我们再往里面深入，如果是4和2组合，首先它们的宽度变成2（往里深入宽度必定减少），高度变成2（高度必定是≤4，），很显然，宽度必定减少，高度最多保持不变，那么4和往里面的树组合体积必定减少，因此就不用考虑4和里面任何数的组合，所以直接忽略4（两侧--6和4中较小的那一个值），数组变成[6,2,5]，然后继续依照上面逻辑，先计算出最外侧两个数的体积，和上一个体积比较，最后直到整个数组被遍历完！

class Solution {
public:
    int triangleNumber(vector<int>& nums) 
    {
        //1.优化
        sort(nums.begin(),nums.end());
        int size = nums.size();
        int fixi = size-1;
        int left = 0;
        int right = fixi-1;
        int ret = 0;
        while(fixi > 1)
        {
            while(left < right)
            {
                if(nums[left] + nums[right] > nums[fixi])
                {
                    ret += right - left;
                    right--;
                }
                else
                {
                  left++;
                }
            }
            fixi--;
            left = 0;
            right = fixi-1;
        }

        return ret;
    }
        
};

题目分析：如果要判断的三个数是有序的（a  <  b  <  c），那么只需要判断一次即可，就是判断 a+b是否大于c，因为b+c肯定大于a，a+c也肯定大于b。

这道题有两种解法，一种是暴力解法，遍历这个数组得到三个数，依次判断是否符合，这种解法的时间复杂度很高。另外一种解法，也是利用双指针的思想，比如给出的数组是[2,3,5,5,7,8,9,12]，先固定一个最大的c，也就是最后的12，然后让left指向剩下的最小的，即2，再让right指向剩下最大的，即9，判断left+right和固定最大值c=12的大小关系，那么就有两种情况：

        1.left+right>c，那么right和left与right中间的任意一个组合都符合条件，不用继续遍历中间的，符合的组数为right-left，再让right--；

        2.left+right<=c，那么，left和left与right中间任意一个组合都不符合条件，left++；

当left=right后，这一回合遍历结束，再让固定的最大值c向前调整一个，然后继续上述步骤即可。

class Solution {
public:
    vector<int> twoSum(vector<int>& price, int target)
    {
        vector<int> ret;
        int size = price.size();
        int left = 0;
        int right = size - 1;
        while(left < right)
        {
            if(price[left] + price[right] < target)
            {
                left++;
            }
            else if(price[left] + price[right] > target)
            {
                right--;
            }
            else
            {
                return {price[left],price[right]};//隐式类型转换
            }
        }
        //虽然我们知道这条语句不会被执行，但是为了照顾编译器，
        //需要在每条返回路径上都返回
        return {1,1};

    }
};

题目分析：和有效三角形的个数的思想非常类似，也是用到双指针的思想。刚开始的时候，左指针left指向数组最左，右指针right指向数组最右，整个数组是单调递增的，先判断left+right和target的关系，分为三种情况：

        1.left+right > target，那么right和left与right之间的任意数之和都大于target，就没有必要继续遍历了，让right--；

        2.left+right < target，那么left和left与right之间的任意数之和都小于target，也没有必要继续遍历了，让left++;

        3.left+right > target，那么直接返回即可，走隐式类型转换。

需要注意的是，需要在循环外加一个return语句，这样编译器才不会报错，认为每条路径都会有返回值。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        int size = nums.size();
        vector<vector<int>> vv;

        for(int i = 0; i < size - 2; )
        {
            if(nums[i] > 0) break;
            int left = i + 1;
            int right = size - 1;
            while(left < right)
            {
                if(-1 * nums[i] < nums[left] + nums[right])
                {
                    right--;
                }
                else if(-1 * nums[i] > nums[left] + nums[right])
                {
                    left++;
                }
                else
                {
                    vv.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 < size && nums[i] == nums[i-1])
            {
                i++;
            }          
        }
        return vv;
    }
};

题目分析：这道题依然是有两种解法：暴力解法和优化解法，

暴力解法：先对数组进行排序，然后对数组中的每三个数进行遍历，当找到三个数的符合条件后，将这三个数的组合插入set中，这样方便去重，但是暴力解法的时间复杂度是O(N3)。

优化解法：先对数组进行排序，然后固定一个数a（从最左侧开始固定），在该数后面的区间内，利用上题“双指针”算法，快速找到这个区间内和为-a的两个数。

处理细节：

1.去重：找到一种结果之后，left和right指针要跳过重复元素，直到找到下一个不重复的元素，当使用完一次双指针算法后，a也要跳过重复元素。

2.不漏：找到一种结果之后，不要“停”，缩小区间，继续寻找

3.小优化：只有a≤0时，才有可能在后面的区间找到两个数之和＝-a，因此a只需要遍历非正值即可。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) 
    {
        //1.排序
        sort(nums.begin(),nums.end());
        //2.按“双指针”查找
        vector<vector<int>> ret;
        int n = nums.size();
        for(int i = 0;i<n;)//固定a
        {
            for(int j=i+1;j<n;)//固定b
            {
                long long val = (long long)target - nums[i] - nums[j];
                int left = j+1;
                int right = n-1;
                while(left < right)
                {
                    int sum = nums[left] + nums[right];
                    if(val > sum)
                    {
                        left++;
                    }
                    else if(val < sum)
                    {
                        right--;
                    }
                    else
                    {
                        ret.push_back({nums[i],nums[j],nums[left],nums[right]});
                        left++;
                        right--;
                        //去重1
                        while(left < right && nums[left] == nums[left-1]) left++;
                        while(left < right && nums[right] == nums[right+1]) right--;
                    }          
                }
                //去重2
                j++;
                while(j < n && nums[j-1] == nums[j]) j++;
            }
            //去重3
            i++;
            while(i < n && nums[i-1] == nums[i]) i++;
        }

        return ret;
    }
};

题目分析：这道题会借用上面三数之和的思想，首先还是对数组进行排序，然后先固定最左边第一个数a，然后从后面区间找出和为target-a的三个数，然后就是借助三数之和的思想，先固定剩下区间的第一个数b，再从剩下区间找和为target-a-b的两个数，然后继续遍历，要和三数之和一样要做到不重不漏。