Leetcode入站必刷：两数、三数、四数之和 | 排序&双指针

前言

本博客是对Leetcode上三道双指针经典题的概括归纳，总结了这一类题的算法思路，以及双指针思想是如何运用的。算法小白必看，看完之后你也能轻松AC这三道题。

这三道题分别是LCR 006.两数之和 LCR 007.三数之和 18.四数之和。本质上，三道题的实现思路是完全一致的，三数之和相比两数之和就是多了对去重的细节控制，而四数之和完全就是套娃…所以建议看懂两数之和的实现思路之后，就尝试自己思考解决三数之和和四数之和，遇到问题再看解析，效果会更好！

LCR 006. 两数之和 II - 输入有序数组 - 力扣（LeetCode）

1. 暴力枚举

暴力枚举一定是新手最容易想到的方法，先固定一个数，然后遍历数组，直到满足要求再直接返回。

由于时间复杂度是O(N²)，最后只通过了18个用例。所以我们需要优化算法。

2. 排序&双指针

对于此类问题，很容易想到用双指针法来优化算法。

我们需要先确保数组是有序的，并让left = 0，right = numbers.size()-1。这样可以根据numbers[left]+numbers[right]与target的大小关系控制左右指针的移动【双指针的运用中常会有这样的条件方程】

因为在left与right逼近的过程中，很容易发现numbers[left]单调递增，numbers[right]单调递减，这让left增大与right减小就对应让两数的和增大、减小。

• 当numbers[left]+numbers[right] < target，说明两数的和当前偏小，我们让较小的数增大。

• 当numbers[left]+numbers[right] > target，说明两数的和当前偏大，我们让较小的数减小。

• 当numbers[left]+numbers[right] = target，两数和满足条件，直接返回。

这样就可以在O(N)的时间复杂度下AC这道题。

参考代码如下：

vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size() - 1;
    while (left < right) {
        if (numbers[left] + numbers[right] == target)
            return {left, right};
        else if (numbers[left] + numbers[right] > target)
            right--;
        else
            left++;
    }
    return {};
}

LCR 007. 三数之和 - 力扣（LeetCode）

三数之和的问题可以转化为两数之和的问题，通过固定一个数，即求两数之和等于target' = target - nums[c]:

另外需要注意在去重的同时，不能漏掉结果。

• 为了做到不漏，在求两数之和的时，就算出现结果，还要继续遍历区间内的其他数
• 为了做到不重，控制指针跳过已经出现过的数即可【因为数组是有序的】

伪代码思路：

do{
	指针移动
}while(指针在范围内 && 该数与上一个数相同)

最终的参考代码如下：

vector<vector<int>> threeSum(vector<int>& nums) {
    	//如果数组中都没有三个数，直接返回
        if (nums.size() < 3)
            return {};

        sort(nums.begin(), nums.end());
        int l, r, f;
        l = 0;
        f = nums.size() - 1;
        r = f - 1;
        vector<vector<int>> res;
    	
    	//第一层循环控制固定的数字
        while (f > 1) {
            //略微优化一下
            if (nums[f] < 0)
                break;
            
            l = 0;
            r = f - 1;
            int target = -nums[f];
            
            //实现两数之和
            while (l < r) {
                if (nums[l] + nums[r] < target) {
                    l++;
                } else if (nums[l] + nums[r] > target) {
                    r--;
                } else {
                    res.push_back(vector<int>({nums[l], nums[r], nums[f]}));
                    if (nums[l] == -1 && nums[r] == 0)
                        int test = 0;
                    do {
                        l++;
                    } while (nums[l - 1] == nums[l] && l < r);

                    do {
                        r--;
                    } while (nums[r + 1] == nums[r] && l < r);
                }
            }
            do {
                f--;
            } while (nums[f + 1] == nums[f] && f > 1);
        }
        
        return res;
    }

时间复杂度为O(N²)，但由于这道题的target为0，还可以稍微优化一下代码：

​ 当固定的数小于0时，就可以跳出循环了。（若三数之和为0，一定有一个数大于等于0）

18. 四数之和 - 力扣（LeetCode）

四数之和的实现思路可以完全照搬三数之和。将问题化繁为简，先转化为三数之和，进而转化为两数之和，就能AC。时间复杂度是O(N³)。

另有一点细节：四数的和可能会整型溢出，在条件判断的时候要转为long，参考代码如下：

vector<vector<int>> fourSum(vector<int>& nums, int target) {
        if(nums.size()<4)return {};

        vector<vector<int>> res;
        sort(nums.begin(),nums.end());
        int a,b,l,r;
        a=nums.size()-1;
    	
    	//固定第一个数
        while(a>2){
            b=a-1;
            
            //固定第二个数
            while(b>1){
                l=0;r=b-1;
                
                //两数之和问题
                while(l<r){
                    if((long)nums[l]+nums[r]<(long)target-nums[a]-nums[b]){
                        l++;
                    }
                    else if((long)nums[l]+nums[r]>(long)target-nums[a]-nums[b]){
                        r--;
                    }
                    else{
                        res.push_back({ nums[a],nums[b],nums[l],nums[r] });

                        do{
                            l++;
                        }while(l<r && nums[l-1]==nums[l]);

                        do{
                            r--;
                        }while(l<r && nums[r+1]==nums[r]);
                    }
                }
                do{
                    b--;
                }while(b>1 && nums[b+1]==nums[b]);
            }
            do{
                a--;
            }while(a>2 && nums[a+1]==nums[a]);
        }
        return res;
    }

四数之和最有内涵的地方在于剪枝，合理利用区间的单调关系，优化算法，进一步提高算法的效率。

有以下三个不等关系，帮助我们优化算法：

• 当固定第一个数后，余下区间内的最大三数之和仍小于目标值
• 当固定第一个数后，余下区间内的最小三数之和仍大于目标值
• 当固定了两个数后，余下区间内的最大两数之和仍小于目标值

至于具体的代码，可以自己思考思考，在想通原理之后，对应的操作也是水到渠成，参考代码如下：

vector<vector<int>> fourSum(vector<int>& nums, int target) {
        if (nums.size() < 4)
            return {};

        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        int a, b, l, r;
        a = nums.size() - 1;
        while (a > 2) {
            // 剪枝
            if ((long)nums[a] + nums[a - 1] + nums[a - 2] + nums[a - 3] <
                target)
                break;
            if ((long)nums[a] + nums[0] + nums[1] + nums[2] > target) {
                do {
                    a--;
                } while (a > 2 && nums[a + 1] == nums[a]);
                continue;
            }

            b = a - 1;
            while (b > 1) {
                // 剪枝
                if ((long)nums[b] + nums[b - 1] + nums[b - 2] <
                    (long)target - nums[a])
                    break;
                if ((long)nums[b] + nums[0] + nums[1] >
                    (long)target - nums[a]) {
                    do {
                        b--;
                    } while (b > 1 && nums[b + 1] == nums[b]);
                }

                l = 0;
                r = b - 1;
                while (l < r) {
                    // 剪枝
                    if ((long)nums[r] + nums[r - 1] <
                        (long)target - nums[a] - nums[b])
                        break;

                    if ((long)nums[l] + nums[r] <
                        (long)target - nums[a] - nums[b]) {
                        l++;
                    } else if ((long)nums[l] + nums[r] >
                               (long)target - nums[a] - nums[b]) {
                        r--;
                    } else {
                        res.push_back({nums[a], nums[b], nums[l], nums[r]});

                        do {
                            l++;
                        } while (l < r && nums[l - 1] == nums[l]);

                        do {
                            r--;
                        } while (l < r && nums[r + 1] == nums[r]);
                    }
                }
                do {
                    b--;
                } while (b > 1 && nums[b + 1] == nums[b]);
            }
            do {
                a--;
            } while (a > 2 && nums[a + 1] == nums[a]);
        }
        return res;
    }

总结

N数之和核心技巧

• 排序后处理：双指针法几乎都依赖于排序后的数组。通过排序，可以利用有序性将题目翻译为某个控制指针移动的条件方程【或直接来自题目，或为某些量之间的不等关系】，进而控制指针的移动。
• 剪枝优化：在每次循环中，可以根据当前的和与目标值的比较，提前剪枝。例如，若固定数太小或太大，则提前跳出循环。
• 避免重复：当涉及到多个元素组合（如三数、四数之和）时，去重是必不可少的步骤。通过跳过相同的元素（nums[i] == nums[i-1]），可以有效避免重复解。
• 双向夹逼：当和符合条件时，可以双向缩小范围，继续寻找其他可能的解。

当然，双指针还会运用到其他算法题中，如链表、滑动窗口… 静待我们一起探索！谢谢你的阅读