【基础算法总结】双指针算法一

点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃

1.移动零

题目链接：283. 移动零

题目描述：

算法原理：

这类题可以归类到一类提里面【数组划分、数组分块】，这类题的特点就是给一个数组然后制定一个规则，在这个规则下把这个数组划分称若干区间

解决这类题首选：双指针算法 ，数组中用双指针利用数组下标充当指针。

两个指针的作用：

cur：从左往右扫描数组，遍历数组
dest：已处理区间内，最后一个元素(本题是最后一个非0元素)

两个指针分三个区间：

【0，dest】已处理区间都是非0元素
【dest+1，cur-1】已处理区间都是0元素
【cur，n-1】待处理元素

初始时，cur在下标1的位置，dest位-1，可能初始时没有非0元素。

cur 从前往后遍历的过程中：

1. 遇到 0 元素：cur++
2. 遇到 非零元素：
   swap（dest+1,cur）
   dest++,cur++

算法代码

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

2.复写零

题目链接：1089. 复写零

题目描述：

算法原理：一个数组，不开辟另一个数组，在原数组内解决问题。

解决方法：双指针算法

先根据 “异地” 操作，然后优化成双指针下的 “就地” 操作。

双指针从左往右，我们发现dest跑到cur前面去了，对于本道题这是不行的。

那试一试从右到左，dest肯定是最后一个数组下标位置，但是cur不好弄，如果初始cur==dest，然后同样会覆盖。因此我们想办法让cur初始时指向数组最后一个复写的数。如果这样复写

1 先找到最后一个 “复写” 的数

这里还可以再用一次双指针算法，（双指针还能套双指针）

1. 先判断 cur 位置的值
2. 决定 dest 向后走一步或者两步
3. 判断一下 dest 是否已经到结束为止
4. cur++

但这里有个问题，dest越界的问题，所以要处理一下边界情况。

cur位置的值是0，dest越界，处理越界问题，下标【n-1】复写0，dest-=2，cur-=1；

2.“从后向前” 完成复写操作

算法代码

class Solution {
public:
    void duplicateZeros(vector<int>& arr) {

        // 1. 先找到最后⼀个数
        int cur = 0, dest = -1, n = arr.size();
        while(cur < n)
        {
            if(arr[cur]) dest++;
            else dest += 2;
            if(dest >= n - 1) break;
            cur++;
        }
        // 2. 处理⼀下边界情况
        if(dest == n)
        {
            arr[n - 1] = 0;
            cur--; dest-=2;
        }
        // 3. 从后向前完成复写操作
        while(cur >= 0)
        {
            if(arr[cur]) arr[dest--] = arr[cur--];
            else
            {
                arr[dest--] = 0;
                arr[dest--] = 0;

                cur--;
            }
        }
    }
};

3.快乐数

题目链接：202.快乐数

题目描述：

解释：（这里省去计算过程，只列出转换后的数）
2 -> 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4 -> 16
往后就不必再计算了，因为出现了重复的数字，最后结果肯定不会是 1

题目分析

为了方便叙述，将【对于一个正整数，每⼀次将该数替换为它每个位置上的数字的平⽅和】这一个操作记为 x 操作；
题目告诉我们，当我们不断重复 x 操作的时候，计算⼀定会【死循环】，死的方式有两种：

• 情况一：⼀直在 1 中死循环，即 1 -> 1 -> 1 -> 1…
• 情况二：在历史的数据中死循环，但始终变不到 1

由于上述两种情况只会出现⼀种，因此，只要我们能确定循环是在【情况⼀】中进行，还是在【情况二】中进行，就能得到结果。

简单证明：

1. 经过一次变化之后的最大值 9^2 * 10 = 810 ( 2^31-1=2147483647 。选一个更大的最大 9999999999 )，也就是变化的区间在 [1, 810] 之间；
2. 根据【鸽巢原理】，一个数变化 811 次之后，必然会形成一个循环；
3. 因此，变化的过程最终会走到一个圈里，因此可以用【快慢指针】来解决

算法原理：
以前做过一种题，判断链表是否有环，我们用的是快慢双指针，

5. 定义快慢指针
6. 慢指针每次向后移动一步，快指针每次向后移动两步
7. 判断相遇时候的值即可

这里我们不能固定思维，快慢指针是一个思想，可以让不同东西代替指针。

这道题我们可以让某个数代替双指针。

class Solution {
public:

    int bitSum(int n)  
    {
        int sum=0;
        while(n)
        {
            int t=n%10;
            sum+=t*t;
            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;

    }
};

4.盛水最多的容器

题目链接：11.盛水最多的容器

题目描述：

题目解析：

算法思路：

解法一：暴力求解(O(N^2)会超时)

枚举出能构成的所有容器，找出其中容积最大的值。

• 容器容积的计算方式：
  设两指针 i , j ，分别指向水槽板的最左端以及最右端，此时容器的宽度为 j - i 。由于容器的⾼度由两板中的短板决定，因此可得容积公式 ： v = (j - i) * min( height[i], height[j] ）

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;
	 }
};

解法二：暴力优化 双指针(对撞指针)

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

            if(height[left] >= height[right])
                --right;
            else
                ++left;
        }
        return ret;

    }
};