【算法系列篇】双指针

文章目录

• 前言
• 什么是双指针算法
• 1.移动零
• • 1.1 题目要求
  • 1.2 做题思路
  • 1.3 Java代码实现
• 2.复写零
• • 2.1 题目要求
  • 2.2 做题思路
  • 2.3 Java代码实现
• 3.快乐数
• • 3.1 题目要求
  • 3.2 做题思路
  • 3.3 Java代码实现
• 4.盛最多水的容器
• • 4.1 题目要求
  • 4.2 做题思路
  • 4.3 Java代码实现
• 5.有效三角形的个数
• • 5.1 题目要求
  • 5.2 做题思路
  • 5.3 Java代码实现
• 6.和为S的两个数字
• • 6.1 题目要求
  • 6.2 做题思路
  • 6.3 Java代码实现
• 7.三数之和
• • 7.1 题目要求
  • 7.2 做题思路
  • 7.3 Java代码实现
• 8.四数之和
• • 8.1 题目要求
  • 8.2 做题思路
  • 8.3 Java代码实现

前言

朋友们，大家好啊，从今天开始我将陆续为大家更新关于算法方面的文章，如果大家对于算法感兴趣的话，欢迎大家订阅我的算法专栏。

什么是双指针算法

双指针算法（Two Pointers Algorithm）是一种常用的算法技巧，通常用于数组、链表或其他线性数据结构中的问题。该算法使用两个指针在数据结构上进行迭代、搜索或比较，以解决特定的问题。

在双指针算法中，通常使用两个指针分别称为”快指针”和”慢指针”。快指针和慢指针起始位置通常相同，然后根据问题的要求，以不同的步长移动指针。快指针可能会每次移动多个位置，而慢指针则每次只移动一个位置。

双指针算法有几种常见的应用方式：

1. 对撞指针（Two Pointers Approach）：快指针从数组的首部开始，慢指针从数组的尾部开始，两者向中间移动，直到它们相遇或交叉。这种方法通常用于有序数组中的搜索、求和等问题。

2. 快慢指针（Fast and Slow Pointers）：快指针和慢指针以不同的速度遍历链表。这种方法通常用于解决链表中的环检测、找到链表中点、链表的反转等问题。

3. 滑动窗口（Sliding Window）：使用两个指针在数组或字符串上定义一个固定大小的窗口，然后根据问题要求移动窗口的起始位置或结束位置。这种方法通常用于字符串或数组中的子串或子数组问题。

双指针算法的优点在于它的时间复杂度通常较低，并且在遍历数据时只需要常量级的额外空间。它可以有效地降低问题的时间复杂度，并且常常用于解决一些数组、链表相关的问题。

1.移动零

https://leetcode.cn/problems/move-zeroes/

1.1 题目要求

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

class Solution {
    public void moveZeroes(int[] nums) {

    }
}

1.2 做题思路

这个题目的目的就是将数组中的所有零给移动到非0数字的右边部分，而我们使用双指针就刚好可以将一个数组分为三部分，第一部分是非零部分，第二部分是数字0，第三部分是待移动的部分。

而这三个部分，我们使用两个指针 slow 和 fast 来维护，当 fast 所指的数字不为 0 时，就与 slow 所指的数字进行交换。这样就可以保证 slow 左边是已经移动之后的非 0 数字，slow 与 fast 之间是移动之后的 0 数字，fast 右边是待移动的部分。

1.3 Java代码实现

class Solution {
    public void moveZeroes(int[] nums) {
        int slow = -1;
        int fast = 0;
        int n = nums.length;
        while(fast < n) {
            if(nums[fast] != 0) {
                int tmp = nums[++slow];
                nums[slow] = nums[fast];
                nums[fast] = tmp;
            }
            fast++;
        }
    }
}

2.复写零

https://leetcode.cn/problems/duplicate-zeros/

2.1 题目要求

给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。

注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

示例 1：

输入：arr = [1,0,2,3,0,4,5,0]
输出：[1,0,0,2,3,0,0,4]
解释：调用函数后，输入的数组将被修改为：[1,0,0,2,3,0,0,4]

示例 2：

输入：arr = [1,2,3]
输出：[1,2,3]
解释：调用函数后，输入的数组将被修改为：[1,2,3]

class Solution {
    public void duplicateZeros(int[] arr) {

    }
}

2.2 做题思路

很多人拿到这个题首先想的是从前往后使用双指针，当遇到0的时候，将0写两次，但是如果这样的话会将后面的数字给覆盖，这就会显得很麻烦。我们不妨换个思路：可以先找到复写之后数组的最后一个数字，然后从后往前进行数据的写入，当遇到0就写两次，非0就写一次。

所以做这个题目大致分为两步：1.找到复写之后数组的最后一个数字 2.从后往前写入数据

2.3 Java代码实现

class Solution {
    public void duplicateZeros(int[] arr) {
        int slow = 0;
        int fast = -1;
        int n = arr.length;
        //1.找到复写之后数组的最后一个数字
        while(fast < n-1) {
            if(arr[slow] != 0) fast++;
            else fast += 2;
            if(fast >= n-1) break;
            slow++;
        }

        //2.调整边界
        //当fast=n的时候，说明slow所指的最后一个数字为0
        if(fast == n) {
            arr[n-1] = 0;
            fast = n-2;
            slow--;
        }

        //3.从后往前写入数据
        while(slow >= 0) {
            if(arr[slow] != 0) {
                arr[fast--] = arr[slow--];
            }else {
                arr[fast--] = 0;
                arr[fast--] = 0;
                slow--;
            }
        }
    }
}

3.快乐数

https://leetcode.cn/problems/happy-number/

3.1 题目要求

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

class Solution {
    public boolean isHappy(int n) {
    
    }
}

3.2 做题思路

要判断是否为快乐数，我们需要知道，当我们进行每位数的平方和这个操作的时候，最终都会形成一个环。

3.3 Java代码实现

class Solution {
    private int bitSum(int n) {
        int sum = 0;
        while(n != 0) {
            int tmp = n % 10;
            sum += tmp*tmp;
            n /= 10;
        }
        
        return sum;
    }

    public boolean isHappy(int n) {
        int slow = n;
        int fast = bitSum(n); //这里先将快指针进行一次求和操作，防止刚开始就相等了
        //slow每次进行一次操作，fast一次进行两次操作
        while(slow != fast) {
            slow = bitSum(slow);
            fast = bitSum(bitSum(fast));
            if(slow == fast) break;
        }

        return slow == 1;
    }
}

4.盛最多水的容器

https://leetcode.cn/problems/container-with-most-water/

4.1 题目要求

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

class Solution {
    public int maxArea(int[] height) {
    
    }
}

4.2 做题思路

容器的容量跟 xy 的乘积有关，所以我们既需要考虑 x，也需要考虑 y，但是无法保证一上来 x 和 y 就是最大的，我们只能保证 x 或者 y 其中一个是最大的，然后再找 xy 最大的时候。所以这里我们先保证 x 是最大的，left 指针指向最左边，right 指针指向最右边，接着再找 x*y 乘积最大。

容积这样计算 (right - left) * min(height[left],height[right])。设置一个变量来存放体积，并不断更新这个变量，保证这个变量存储的是容积最大的数据。left 和 right 的值也是需要不断改变的，需要更换掉 left 和 right 所指向的数据较小的指针，因为我们要找的是乘积最大的数据。

• 容器的宽度⼀定变⼩。
• 由于左边界较⼩，决定了⽔的⾼度。如果改变左边界，新的⽔⾯⾼度不确定，但是⼀定不会超过右边的柱⼦⾼度，因此容器的容积可能会增⼤。
• 如果改变右边界，⽆论右边界移动到哪⾥，新的⽔⾯的⾼度⼀定不会超过左边界，也就是不会超过现在的⽔⾯⾼度，但是由于容器的宽度减⼩，因此容器的容积⼀定会变⼩的

4.3 Java代码实现

class Solution {
    public int maxArea(int[] height) {
        int n = height.length;
        int left = 0;
        int right = n-1;
        int ret = 0;  //用来存储体积
        while(left < right) {
            int v = (right - left) * Math.min(height[left],height[right]);
            ret = Math.max(v,ret);
            if(height[left] < height[right]) left++;
            else right--;
        }

        return ret;
    }
}

5.有效三角形的个数

https://leetcode.cn/problems/valid-triangle-number/

5.1 题目要求

给定一个包含非负整数的数组 nums ，返回其中可以组成三角形三条边的三元组个数。

示例 1:

输入: nums = [2,2,3,4]
输出: 3
解释:有效的组合是:
2,3,4 (使用第一个 2)
2,3,4 (使用第二个 2)
2,2,3
示例 2:

输入: nums = [4,2,3,4]
输出: 4

class Solution {
    public int triangleNumber(int[] nums) {

    }
}

5.2 做题思路

说的有效的三角形，大家应该都不陌生吧：任意两边之和大于第三边，但是，我们真的需要两两组合都判断一遍吗，其实并不是的，只需要判断两个较短的边之和大于较长的那个边就可以了。

既然知道了只需要判断一次就可以判断是否是有效的三角形，所以我们可以先对数组进行一个升序排序，从数组的最后开始，将它作为三角形的最长的边，然后在前面的数组范围内，left 指针指向前面部分的最左边，right 指针指向最右边，通过移动 left 和right 的位置来统计有效三角形的个数。如果 nums[left] + nums[right} > 最长的边，那么从 left 开始到 right – 1 的边和 right、最长的边都可以组合成一个有效的三角形；所以，以该长度为最长边的三角形的个数为 right -left，然后right–，继续该操作，直到left == right；如果 nums[left] + nums[right} < 最长的边，就需要移动 left 的位置，直到遇到 nums[left] + nums[right} > 最长的边 的位置，再统计有效三角形的个数。

5.3 Java代码实现

class Solution {
    public int triangleNumber(int[] nums) {
        Arrays.sort(nums);
        int sum = 0;
        for(int i = nums.length-1; i > 1; i--) {
            int left = 0;
            int right = i-1;
            while(left < right) {
                if(nums[left] + nums[right] > nums[i]) {
                    sum = sum + right - left;
                    right--;
                }else {
                    left++;
                }
            }
        }

        return sum;
    }
}

6.和为S的两个数字

https://leetcode.cn/problems/he-wei-sde-liang-ge-shu-zi-lcof/

6.1 题目要求

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

class Solution {
    public int[] twoSum(int[] nums, int target) {

    }
}

6.2 做题思路

这个题目的思路跟上面的思路差不多。使用双指针，left 指向数组的最左边（也就是最小值），right 指向数组的最右边（最大值），然后判断 nums[left] + nums[right] 跟target 的关系，如果 nums[left] + nums[right] > target ，就调整 right 的值；如果 nums[left] + nums[right] < target 就调整 left 的值，如果相等就存下来。

6.3 Java代码实现

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left < right) {
            int sum = nums[left] + nums[right];
            if(sum > target) {
                right--;
            }else if(sum < target) {
                left++;
            }else {
                return new int[]{nums[left],nums[right]};
            }
        }

        return new int[]{-1,-1};
    }
}

7.三数之和

https://leetcode.cn/problems/3sum/

7.1 题目要求

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。
示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {

    }
}

7.2 做题思路

当直到了如何解决两数之和的问题之后，求三数值和其实也很简单，还是现将数组以升序的方式排序我们每次固定一个数字，然后在剩下的数组中找到和为 target – nums[i] 的值，但是真的有这么简单吗？注意看题目，答案中不可出现重复的三元组，什么叫做重复的三元组，看第一个示例，它等于 target 的三个数有 (-1,0,1),(0,1,-1),(-1,2,-1) ，但是最终输出的结果只有[[-1,-1,2],[-1,0,1]]，所以这道题关键难在去重这个问题上，那么我们应该如何去重呢？当调整 left、right 和那个固定的数字的时候，如果所指的数字等于前面的数字那么就跳过。

7.3 Java代码实现

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        int n = nums.length;
        int i = 0;
        while(i < n && nums[i] <= 0) {
            int left = i + 1;
            int right = n - 1;
            int target = -nums[i];
            while(left < right) {
                int sum = nums[left] + nums[right];
                if(sum > target) {
                    right--;
                }else if(sum < target) {
                    left++;
                }else {
                    List<Integer> list1 = new ArrayList<>();
                    list1.add(nums[i]);
                    list1.add(nums[left]);
                    list1.add(nums[right]);
                    list.add(list1);
                    left++;
                    right--;
                    //去重并且防止越界
                    while(left < right && nums[left] == nums[left-1]) left++;
                    while(left < right && nums[right] == nums[right+1]) right--;
                }
            }
            i++;
            while(i < n && nums[i] <= 0 && nums[i] == nums[i-1]) i++;
        }
        return list;
    }
}

8.四数之和

https://leetcode.cn/problems/4sum/

8.1 题目要求

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {

    }
}

8.2 做题思路

这个求四数之和，如果前面的两数之和和三数之和会做了，这个题目也很简单，我们只需要先固定一个数字，然后在后面的数组内找到和为 target – nums[i] 的三个数就行了，唯一需要注意的就是去重。那么这个题目我就不过多介绍了，大家直接看代码就行了。

8.3 Java代码实现

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<>();
        int i = 0;
        int n = nums.length;
        Arrays.sort(nums);
        while(i < n) {
            int j = i + 1;
            long tmp1 = target-nums[i];
            while(j < n) {
                int slow = j + 1;
                int fast = n-1;
                long tmp2 = tmp1 - nums[j];
                while(slow < fast) {
                    int sum = nums[slow] + nums[fast];
                    if(sum > tmp2) {
                        fast--;
                    }else if(sum < tmp2) {
                        slow++;
                    }else {
                        List<Integer> list1 = new ArrayList<>();
                        list1.add(nums[i]);
                        list1.add(nums[j]);
                        list1.add(nums[slow]);
                        list1.add(nums[fast]);
                        list.add(list1);
                        slow++;
                        fast--;
                        while(slow < fast && nums[slow] == nums[slow-1]) slow++;
                        while(slow < fast && nums[fast] == nums[fast+1]) fast--;
                    }
                }
                j++;
                while(j < n && nums[j] == nums[j-1]) j++;
            }
            i++;
            while(i < n && nums[i] == nums[i-1]) i++;
        }

        return list;
    }
}