【算法优选】双指针专题—

这篇具有很好参考价值的文章主要介绍了【算法优选】双指针专题——叁。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

😎前言

常⻅的双指针有两种形式，⼀种是对撞指针，⼀种是左右指针
对撞指针：⼀般⽤于顺序结构中，也称左右指针。

对撞指针从两端向中间移动。⼀个指针从最左端开始，另⼀个从最右端开始，然后逐渐往中间逼近。
对撞指针的终⽌条件⼀般是两个指针相遇或者错开（也可能在循环内部找到结果直接跳出循环），也就是：

left == right （两个指针指向同⼀个位置）
left > right （两个指针错开）

快慢指针：⼜称为⻳兔赛跑算法，其基本思想就是使⽤两个移动速度不同的指针在数组或链表等序列结构上移动。

这种⽅法对于处理环形链表或数组⾮常有⽤。其实不单单是环形链表或者是数组，如果我们要研究的问题出现循环往复的情况时，均可考虑使⽤快慢指针的思想。快慢指针的实现⽅式有很多种，最常⽤的⼀种就是：

在⼀次循环中，每次让慢的指针向后移动⼀位，⽽快的指针往后移动两位，实现⼀快⼀慢

🌳两数之和

🚩题目描述：

购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。

示例 1：
输入：price = [3, 9, 12, 15], target = 18
输出：[3,15] 或者 [15,3]
示例 2：
输入：price = [8, 21, 27, 34, 52, 66], target = 61
输出：[27,34] 或者 [34,27]

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

🚩算法思路：

注意到本题是升序的数组，因此可以⽤「对撞指针」优化时间复杂度

🚩算法流程：

初始化 left ， right 分别指向数组的左右两端（这⾥不是我们理解的指针，⽽是数组的下标）
当 left < right 的时候，⼀直循环

当 nums[left] + nums[right] == target 时，说明找到结果，记录结果，并且
返回；
当 nums[left] + nums[right] < target 时：

• 对于 nums[left] ⽽⾔，此时 nums[right] 相当于是 nums[left] 能碰到的最⼤值（别忘了，这⾥是升序数组哈~）。如果此时不符合要求，说明在这个数组⾥⾯，没有别的数符合 nums[left]的要求了（最⼤的数都满⾜不了你，你已经没救了）。因此，我们可以⼤胆舍去这个数，让 left++ ，去⽐较下⼀组数据；

• 那对于nums[right] ⽽⾔，由于此时两数之和是⼩于⽬标值的， nums[right] 还可以选择⽐ nums[left]⼤的值继续努⼒达到⽬标值，因此 right 指针我们按兵不动；

当 nums[left] + nums[right] > target时，同理我们可以舍去nums[right] （最⼩的数都满⾜不了你，你也没救了）。让 right-- ，继续⽐较下⼀组数据，⽽ left 指针不变（因为他还是可以去匹配⽐ nums[right] 更⼩的数的）。

🚩代码实现

class Solution {
  public int[] twoSum(int[] nums, int target) {
        int left = 0, 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[]{0};
    }
}

🎄三数之和

🚩题目描述

给你一个整数数组 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) {

    }
}

🚩算法思路：

本题与两数之和类似，是⾮常经典的⾯试题。
与两数之和稍微不同的是，题⽬中要求找到所有「不重复」的三元组。那我们可以利⽤在两数之和那⾥⽤的双指针思想，来对我们的暴⼒枚举做优化：

先排序；
然后固定⼀个数a ：
在这个数后⾯的区间内，使⽤「双指针算法」快速找到两个数之和等于 -a即可。
但是要注意的是，这道题⾥⾯需要有「去重」操作~

找到⼀个结果之后， left 和 right指针要「跳过重复」的元素；
当使⽤完⼀次双指针算法之后，固定的 a 也要「跳过重复」的元素

🚩代码实现：

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();
        // 1. 排序
        Arrays.sort(nums);
        // 2. 利⽤双指针解决问题
        int n = nums.length;
        // 固定数 a
        for(int i = 0; i < n; ) {
            if(nums[i] > 0) {
                break; // ⼩优化
            }
            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 {
                    // 添加nums[i] nums[left] num[right]
                    ret.add(new ArrayList<Integer>(Arrays.asList(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 < n && nums[i] == nums[i - 1]) {
                i++;
            }
        }
        return ret;
    }
}

🌴四数之和

🚩题目解析

给你一个由 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]]

🚩算法思路：

依次固定⼀个数 a ；
在这个数 a 的后⾯区间上，利⽤「三数之和」找到三个数，使这三个数的和等于 target-a 即可。

🚩代码实现：

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> ret = new ArrayList<>();
        // 1. 排序
        Arrays.sort(nums);
        // 2. 利⽤双指针解决问题
        int n = nums.length;
        // 固定数 a
        for(int i = 0; i < n; ) {
            // 三数之和
            // 固定数 b
            for(int j = i + 1; j < n; ) {
                // 双指针
                int left = j + 1;
                int right = n - 1;
                long aim = (long)target - nums[i] - nums[j];
                while(left < right) {
                    int sum = nums[left] + nums[right];
                    if(sum > aim) {
                        right--;
                    } else if(sum < aim) {
                        left++;
                    } else {
                        ret.add(Arrays.asList(nums[i], nums[j], nums[left++], nums[right--]));
                        // 去重⼀
                        while(left < right && nums[left] == nums[left - 1]) {
                            left++;
                        }
                        while(left < right && nums[right] == nums[right + 1]) {
                            right--;
                        }
                    }
                }
                // 去重⼆
                j++;
                while(j < n && nums[j] == nums[j - 1]) {
                    j++;
                }
            }
            // 去重三
            i++;
            while(i < n && nums[i] == nums[i - 1]) {
                i++;
            }
        }
        return ret;
    }
}