【Java算法】双指针（上）

🔥个人主页： 中草药

🔥专栏：【算法工作坊】算法实战揭秘

---

🌽一.移动零

题目链接：283.移动零

🌶️算法原理 

双指针策略

• dest指针（初始化为-1）：这个指针用来追踪下一个非零元素应该放置的位置。之所以初始值设为-1，是因为在第一个非零元素出现前，我们还没有开始移动任何元素，因此dest会在首次遇到非零元素时被更新为0，从而确保非零元素从数组的第一个位置开始填充。

• cur指针（初始化为0）：这个指针遍历整个数组。它负责检查当前元素是否为0，如果不是0，则与dest指向的元素交换，之后dest向前推进一位，表示下一个非零元素应放置的位置。

代码步骤分解

1. 初始化双指针：dest初始为-1，表示尚未开始移动非零元素；cur初始为0，开始遍历数组。

2. 遍历数组：使用cur指针从头至尾遍历数组中的每个元素。

3. 检查并交换元素：对于cur指向的元素，如果它不是0，执行以下操作：

   • dest加1，表示找到了一个新的非零元素的正确位置。
   • 将nums[dest]和nums[cur]交换，确保非零元素被移到前面。

   这样，所有的非零元素都会逐渐被移到数组的前端，而0元素自然被推到了数组的末尾。

4. 遍历结束：当cur遍历完整个数组后，所有非零元素已经按照原来的相对顺序被移动到了数组的前部，而数组的末尾则是连续的0。

在Java中无需创立指针，只需通过索引下标来达到访问数组元素的目的

        所以划分为三个区间，[0,dest]最左边全为非零元素,[dest+1,cur-1]中间部分为0,[cur,n-1],右边为待处理元素，只要在移动过程中一直保持各区间的性质，当cur指针移动到n为止时，区间划分完毕 

🫑代码

class Solution {
    public void moveZeroes(int[] nums) {
        for(int dest=-1,cur=0;cur<nums.length;cur++){
            if(nums[cur]!=0){
                dest++;
                int temp=nums[dest];
                nums[dest]=nums[cur];
                nums[cur]=temp;
            }
        }
    }
}

代码效率

• 时间复杂度：O(n)，其中n是数组的长度。每个元素最多被访问两次（一次由cur访问，一次由dest访问或交换），因此整体的时间复杂度是线性的。
• 空间复杂度：O(1)，因为只使用了常数个额外变量，没有使用与输入规模相关的额外空间。

🥒举例 

测试用例 nums = [0, 1, 0, 3, 12]

初始化

• dest = -1，表示当前还没有找到任何非零元素需要移动的位置。
• cur = 0，开始遍历数组。

遍历过程

第一轮迭代（cur = 0）

• nums[cur] = 0，当前元素是0，不进行任何交换，dest保持不变。
• 数组状态未变。

第二轮迭代（cur = 1）

• nums[cur] = 1，当前元素非0，需要将其移动到dest所在的位置。
  • dest从-1变为0（首次遇到非零元素）。
  • 交换nums[dest]和nums[cur]，即交换nums[0]和nums[1]，得到nums = [1, 0, 0, 3, 12]。
  • dest递增1，变为1。

第三轮迭代（cur = 2）

• nums[cur] = 0，当前元素是0，不进行交换，dest保持为1。
• 数组状态未变：nums = [1, 0, 0, 3, 12]。

第四轮迭代（cur = 3）

• nums[cur] = 3，当前元素非0，需要移动。
  • 交换nums[dest]（当前是第二个元素，值为0）和nums[cur]（值为3），得到nums = [1, 3, 0, 0, 12]。
  • dest递增1，变为2。

第五轮迭代（cur = 4）

• nums[cur] = 12，当前元素非0，需要移动。
  • 交换nums[dest]（当前是第三个元素，值为0）和nums[cur]（值为12），得到nums = [1, 3, 12, 0, 0]。
  • dest递增1，变为3。

结束

• 当cur达到数组末尾时，遍历结束。此时，所有非零元素已按原顺序移至数组前端，而0元素被推至末尾。

最终数组状态为：nums = [1, 3, 12, 0, 0]，符合题目要求。

🥬二.复写零

题目链接：1089.复写零

🥦算法原理 

双指针策略

• cur指针（初始化为0）：负责从数组的起始位置向前遍历，用于查找0元素并计算复制0后的新数组布局，记录最后数组末尾元素的值

• dest指针（初始化为-1）：表示新数组（考虑复制0后的数组）的当前写入位置。由于是从后向前写入，初始化为-1是为了方便处理首个元素的写入。

代码步骤分析

1. 预计算：首先通过cur遍历数组，计算出在不考虑数组越界的情况下，所有0元素复制后，dest应该到达的位置。如果遇到0，dest向前移动两位，否则移动一位。当dest超过数组最后一个有效位置（即n-1）时，停止计算。

2. 处理边界特殊情况：如果预计算后dest恰好等于数组长度n，说明最后一个元素是0，但由于数组已满，只能复制一个0到数组末尾，然后相应调整dest和cur的位置。

3. 从后向前复制：从数组的末尾开始，使用cur指针反向遍历，如果是非0元素，则直接复制到dest位置；如果遇到0，则先复制一个0，dest减2，再复制另一个0，dest再减1，cur也相应减1，以跳过原始的0元素。

🧄代码

public void duplicateZeros(int[] arr) {
        int n=arr.length;
        int cur = 0;
        int dest = -1;
        //用cur遍历数组，找到最后一个需要复习的数字
        while(cur<n){
            if(arr[cur]==0){
                dest+=2;
            }else{
                dest++;
            }
            if(dest>=n-1){
                break;
            }
            cur++;
        }
        //处理一下边界特殊情况
        if(dest==n){
            arr[n-1]=0;
            dest-=2;
            cur--;
        }
        //从后往前复写
        while(cur>=0){
            if(arr[cur]!=0){
                arr[dest--]=arr[cur--];
            }else{
                arr[dest--]=0;
                arr[dest--]=0;
                cur--;
            }
        }
    }

代码效率

• 时间复杂度：O(n)，其中n是数组的长度。每个元素最多被访问两次（一次由cur访问，一次由dest访问或交换），因此整体的时间复杂度是线性的。
• 空间复杂度：O(1)，因为只使用了常数个额外变量，没有使用与输入规模相关的额外空间。

🧅举例 

测试用例 arr =[1,0,2,3,0,4,5,0]

初始化

• n = 8，数组长度为8。
• cur = 0，开始遍历数组。
• dest = -1，初始写入位置标记。

预计算阶段

1. 第一轮 (cur = 0, arr[cur] = 1): dest = -1 + 1 = 0，因为当前元素不是0，所以dest只向前移动1位。
2. 第二轮 (cur = 1, arr[cur] = 0): dest = 0 + 2 = 2，遇到0，需要预留两个位置。
3. 第三轮 (cur = 2, arr[cur] = 2): dest = 2 + 1 = 3，非0元素，dest前进1位。
4. 第四轮 (cur = 3, arr[cur] = 3): dest = 3 + 1 = 4，同上。
5. 第五轮 (cur = 4, arr[cur] = 0): dest = 4 + 2 = 6，再次遇到0，预留两个位置。
6. 第六轮 (cur = 5, arr[cur] = 4): dest = 6 + 1 = 7，非0元素。
7. 第七轮 (cur = 6, arr[cur] = 5): dest = 7 + 1 = 8，非0元素，但此时dest >= n-1，停止计算。

处理边界特殊情况

• 由于dest == n，说明最后一个元素为0且无法完全复制第二个0，因此仅将一个0复制到数组末尾。此时，dest -= 2变为6，cur -= 1变为5，准备从后向前复制。

从后向前复制

1. 第一步 (cur = 5, arr[cur] = 4): 直接复制arr[dest--] = arr[cur--] = 4，此时dest = 5, cur = 4。
2. 第二步 (cur = 4, arr[cur] = 0): 遇到0，先复制一个0，arr[dest--] = 0，dest = 4，再复制第二个0，arr[dest--] = 0，dest = 3，cur = 3。
3. 第三步 (cur = 3, arr[cur] = 3): 直接复制arr[dest--] = arr[cur--] = 3，dest = 2, cur = 2。
4. 第四步 (cur = 2, arr[cur] = 2): 直接复制arr[dest--] = arr[cur--] = 2，dest = 1, cur = 1。
5. 第五步 (cur = 1, arr[cur] = 0): 再次遇到0，先复制一个0，arr[dest--] = 0，dest = 0，再复制第二个0，arr[dest--] = 0，此时dest = -1，超出预期范围，但因为我们是从后向前复制，且已正确处理完所有元素，故忽略此细节，cur = 0。

最终结果

经过上述操作，数组变为[1, 0, 0, 2, 3, 0, 0, 4]，符合题目要求，即每个0元素都被复制了一次，且非0元素的相对顺序保持不变。

🥜三.开心数

题目链接：202.快乐数

🫘算法原理 

        这段代码虽然涉及到“双指针”概念，但其实质上是利用了“快慢指针”（Floyd's cycle-finding algorithm，也称作龟兔赛跑算法）的思想来检测一个数字运算过程中的循环，而非传统意义上的双指针遍历数据结构。下面详细分析其算法原理：

bitsum 方法

        该方法计算一个整数的“数字平方和”。具体来说，它将输入整数n的每一位数字提取出来（通过n % 10），对该数字求平方后累加到sum中，然后去除该位（通过n /= 10）。这个过程重复，直到n变为0，最终返回累加的平方和。这是判断快乐数过程中的一项基本操作。

isHappy 方法

        该方法用于判断一个整数是否为“快乐数”。关键在于使用了“快慢指针”的思想来检测计算过程中是否存在循环。

• 初始化：定义两个指针slow和fast，初始时slow直接等于n，fast等于bitsum(n)，即fast先进行一次计算。

• 循环判断：在while循环中，slow每次迭代调用一次bitsum进行下一步计算，模拟“慢指针”；而fast则每次迭代调用两次bitsum，模拟“快指针”。如果slow和fast最终指向相同的值（即它们相遇），则表明进入了一个循环。

• 循环结束条件：循环结束有两种可能，一种是发现循环（slow == fast），另一种是直接发现slow或fast（在循环外的条件下）变成了1，这在代码中体现为循环结束后单独判断slow == 1。理论上，如果n是快乐数，通过上述过程，slow和fast最终会在值为1时相遇，因为1是快乐数循环的唯一不动点。

快慢指针算法的应用

• 检测循环：在本例中，快慢指针用于检测“数字平方和”计算过程中的循环。如果存在非1的循环（例如4->16->37->58->89->145->42->20->4->16...），则表明这个数字不是快乐数。
• 效率提升：相较于无脑循环直到发现重复或达到1的传统方法，快慢指针法能显著减少计算次数，提高算法效率。

总之，这段代码巧妙地将“快慢指针”算法应用于判断快乐数的问题上，通过检测数字运算的循环性来高效判断一个数是否为快乐数。

🍞代码

class Solution {
    public int bitsum(int n){
        int sum=0;
        while(n!=0){
            int temp=n%10;
            sum +=temp*temp;
            n/=10;
        }
        return sum;
    }

    public boolean isHappy(int n) {
        int slow=n;
        int fast=bitsum(n);
        while(slow!=fast){
            slow=bitsum(slow);
            fast=bitsum(bitsum(fast));
        }
        
        return slow==1;
    }
}

代码效率

时间复杂度

1. bitsum方法: 对于任意整数n，计算其每位数字的平方和的时间复杂度为O(log n)，因为每次循环都将n除以10，直到n变为0，而整数的位数大致与log n成正比。

2. isHappy方法: 关键在于快慢指针检测循环的效率。在最坏情况下，快指针（fast）每次迭代相当于bitsum操作两次，而慢指针（slow）每次迭代bitsum操作一次。由于快慢指针相遇的原理基于Floyd判圈算法，其时间复杂度与检测到循环的步数有关。在理想情况下，如果n不是快乐数且很快进入循环，时间复杂度接近线性，但最坏情况下（比如接近循环起点的数），快慢指针相遇前的操作次数与循环体的长度有关。不过，考虑到任何非快乐数最终都会落入一个已知的循环（如4->16->37->58->89->145->42->20->4...），该循环体长度有限，因此整体的时间复杂度可以视为O(log n)。

空间复杂度

• 整个算法的空间复杂度为O(1)，因为它只使用了固定数量的变量（如sum, slow, fast, temp, n等），并不依赖于输入整数的大小。

🥐举例

测试用例 n=19

初始设置

• 输入n = 19。
• slow初始化为n，即slow = 19。
• fast初始化为其平方和，即调用bitsum(19)。

计算bitsum(19)

• 19的各位数字为1和9。
• 平方和为1^2 + 9^2 = 1 + 81 = 82。
• 所以，fast = 82。

开始循环

• 第1轮:

  • slow = bitsum(19) = 82。
  • fast = bitsum(bitsum(82))，首先计算bitsum(82)：
    • 82的各位数字为8和2。
    • 平方和为8^2 + 2^2 = 64 + 4 = 68。
    • 然后再次调用bitsum(68)：
      • 68的各位数字为6和8。
      • 平方和为6^2 + 8^2 = 36 + 64 = 100。
    • 所以，fast = 100。
  • 此时slow = 82，fast = 100，不相等，继续循环。

• 第2轮:

  • slow = bitsum(82)，已知上一轮计算结果为68。
  • fast = bitsum(bitsum(100))，先计算bitsum(100)：
    • 100的各位数字为1和两个0（注意，0的平方和仍为0）。
    • 平方和为1^2 + 0^2 + 0^2 = 1。
    • 再次调用bitsum(1)：
      • 1的平方和为1^2 = 1。
    • 所以，fast = 1。
  • 此时slow = 68，fast = 1，不相等，继续循环。

• 第3轮:

  • slow = bitsum(68)，计算得：
    • 68的各位数字为6和8。
    • 平方和为6^2 + 8^2 = 36 + 64 = 100。
    • 所以，slow = 100。
  • fast已经在上一轮计算为1，保持不变。
  • 此时slow = 100，fast = 1，不相等，继续循环。

• 第4轮:

  • slow = bitsum(100)，已知上一轮计算结果为1。
  • fast = 1，保持不变。
  • 此时slow = 1，fast = 1，两者相等，循环结束。

结果判断

由于循环结束时slow和fast都等于1，根据return slow == 1;的逻辑，得出结论：n=19是一个快乐数。

🥖四.盛最多水的容器

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

🫓算法原理 

        这段代码是使用Java编写的，实现了一个经典的双指针算法来解决“容器盛水最大值”问题。给定一个非负整数数组height，该数组代表了一个竖直的直线序列，数组中的每个元素代表对应位置的垂直高度。此代码的目标是找到两个线段（两条直线），使得这两条线段和x轴围成的容器能够容纳最多的水。

• 初始化：定义两个指针left和right，分别指向数组的首尾，即left = 0和right = height.length - 1。同时初始化一个变量ret来保存当前最大容积，初始值设为0。

• 双指针移动策略：在while循环中，只要left < right，即两个指针没有相遇，循环就会持续进行。每轮循环计算当前两指针构成的容器的容量，公式为v = Math.min(height[left], height[right]) * (right - left)，即两指针高度中的较小值乘以两指针之间的距离。

• 更新最大容积：用当前容量v与已知最大容积ret比较，如果当前容量更大，则更新ret的值为当前容量。

• 指针移动规则：根据高度决定移动哪个指针。如果height[left] <= height[right]，说明左边的墙矮或者一样高，此时向右移动左指针（即增大左侧高度的可能性更大）；反之，如果右边的墙更矮，则向左移动右指针。这是因为，为了可能找到更大的面积，我们需要尝试缩小高度较低的那一侧，寄希望于另一侧能找到更高的墙。

• 循环结束：当left >= right时，说明左右指针相遇或交错，循环结束，此时ret中存储的就是最大的盛水量。

        这段代码高效地解决了“容器盛水最大值”问题，通过双指针策略从两端向中间逼近，减少了不必要的遍历，体现了动态规划中“空间换时间”的思想，是算法优化的一个典型示例。 

🥨代码

class Solution {
    public int maxArea(int[] height) {
        int left=0;
        int right=height.length-1;
        int ret=0;
        while(left<right){
            int v=Math.min(height[left],height[right])*(right-left);
            ret=Math.max(ret,v);
            if(height[left]<=height[right]){
                left++;
            }else{
                right--;
            }
        }
        return ret;
    }
}

代码效率

• 时间复杂度：O(n)，其中n为数组height的长度。因为双指针只会遍历数组一次。
• 空间复杂度：O(1)，除了输入数组外，只使用了常数级别的额外空间。

🥯举例

测试用例 [1,8,6,2,5,4,8,3,7]

针对给定数组[1,8,6,2,5,4,8,3,7]，我们来详细分析上述代码的每一步执行过程，以找出该数组中能够构成的最大容器盛水量。

初始设置

• left = 0，指向数组起始位置，对应高度height[0] = 1。
• right = 8，指向数组末尾位置，对应高度height[8] = 7。
• ret = 0，初始化最大容积为0。

执行过程

第1步

• 左边高度height[left] = 1，右边高度height[right] = 7。
• 计算当前容器容量v = min(1, 7) * (8 - 0) = 1 * 8 = 8。
• 更新最大容积ret = max(0, 8) = 8。
• 因为height[left] <= height[right]，移动左指针left，left = left + 1 = 1。

第2步

• 左边高度变为height[left] = 8，右边高度保持height[right] = 7。
• 计算当前容器容量v = min(8, 7) * (8 - 1) = 7 * 7 = 49。
• 更新最大容积ret = max(8, 49) = 49。
• 移动左指针left = left + 1 = 2。

第3步

• 左边高度变为height[left] = 6，右边高度保持height[right] = 7。
• 计算当前容器容量v = min(6, 7) * (8 - 2) = 6 * 6 = 36。
• 由于ret = 49，不需要更新最大容积。
• 移动左指针left = left + 1 = 3。

后续步骤

• 按照同样的逻辑，继续比较、计算、更新和移动指针：
  • 当left = 3，height[left] = 2时，计算得到v = 2 * 5 = 10，不更新ret。
  • 当left = 4，height[left] = 5时，计算得到v = 5 * 4 = 20，不更新ret。
  • 随后，当left继续移动，由于高度逐渐降低，且右侧高度不再增长，计算的容量不会再超过ret = 49。

循环结束

• 当left和right相遇或交错时，循环结束。在这个过程中，已经找到了最大容器盛水量为49。

结果

最终，针对数组[1,8,6,2,5,4,8,3,7]，通过双指针算法分析，确定的最大容器盛水量为49。 

---

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐

  制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸