15. 三数之和(中等)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/xuchonghao/article/details/79837681

一、题意
给定一个包含 n 个整数的数组 S,是否存在属于 S 的三个元素 a,b,c 使得 a + b + c = 0 ?找出所有不重复的三个元素组合使三个数的和为零。

注意:结果不能包括重复的三个数的组合。

例如, 给定数组 S = [-1, 0, 1, 2, -1, -4],

一个结果集合为:
[
[-1, 0, 1],
[-1, -1, 2]
]
二、分析和解答
1、对两个数的和进行分析
之前使用的HashSet的空间占用时间解决的两个数的和,因为那个题返回的是两个数的下标,所以不能进行排序。
如果返回的值不是下标,而是数组中的值。
先对其进行排序(从左至右依次增大),再设置两个指针 i,j 分别指向数组两端:如果两指针所指向数的和大于target,j指针前移,找一个更小的数;如果两指针所指向数的和小于target,i指针后移,找一个更大点的数;如果相同,则返回即可。
2、三数的和
对两个数的和的扩展。对每个数遍历,求两个数的和为0 - nums[k]即可。代码如下:

 public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        Arrays.sort(nums);
        for(int k=0;k<nums.length;k++){
            int i = k+1,j = nums.length - 1;//***
            while(i < j){              
                int value = nums[i] + nums[j];
                if(value == (-nums[k])){
                    List<Integer> list = new ArrayList();
                    list.add(nums[k]);
                    list.add(nums[i]);
                    list.add(nums[j]);
                    res.add(list);
                    //重值处理
                    //****一定要有i < j条件,否则i会到最后
                    while(i<j && nums[i] == nums[i+1]){
                        i++;
                    }
                    //****一定要有i < j条件,否则j会取-1
                    while(i<j && nums[j] == nums[j-1]){
                        j--;
                    }
                    //***
                    i++;
                    j--;
                }
                else if(value < (-nums[k]))
                    i++;
                else
                    j--;
            }
            //****重值处理
            while(k < nums.length-1 && nums[k] == nums[k+1]){
                k++;
            }
        }
        return res;
    }

虽然思想比较简单,但是还是有很多很多难点:
(1)i 的取值。这是一个难点:0 - nums[k] 为我们所求的target,即两个数的和为target,这两个数必须是k值之后的两个位置,而不可能处于k位置之前。
a)设nums=[a1,a2,a3,a4…an],当第一个数为a1时,和为0-a1的第二三个数的位置处于【a2–an】之间,设为ax和ay,那么有ax + ay = 0 - a1
b)那么,当第一个数为a2的时候,target为0 - a2,如果存在一个在a2之前的数为第二个数为a1,假设第三个数为ax,也就是说a1 + ax = 0 - a2,可以换为a2 + ax = 0 - a1
因此,这是b)中如果去当前值前面位置的数,和a)的情况就发生重合。

(2)重值问题。有两个级别的重值进行处理,以[-1,0,1,2,-1,-4]为例,进行排序后为[-4,-1,-1,0,1,2],如果是比较原始的代码,不进行重值处理的时候,代码如下:

  public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        Arrays.sort(nums);
        for(int k=0;k<nums.length;k++){        
            int i = k+1,j = nums.length - 1;
            while(i < j){                                 
                int value = nums[i] + nums[j];
                if(value == (-nums[k])){
                    List<Integer> list = new ArrayList();
                    list.add(nums[k]);
                    list.add(nums[i]);
                    list.add(nums[j]);
                    res.add(list);

                    i++;//暂且这么写
                    j--;
                }
                else if(value < (-nums[k]))
                    i++;
                else
                    j--;
            }

        }
        return res;
    }
输出:[[-1,-1,2],[-1,0,1],[-1,0,1]]
预期:[[-1,-1,2],[-1,0,1]]

会发现多了一个[-1,0,1]。

a)所以第一个是在k层次(外面的那层循环)上进行去重:[-4,-1,-1,0,1,2] 第二个位置为-1,可以得到这个答案,但第三个位置也是-1,也可以得到这个答案。这种去重想法很简单:只要判断nums[i]和它的前一位或者后一位是否相同即可,若相同就跳过!但是关键是把这种判断放在哪里?
我一开始把它放在了for循环的下面,即在得到三个合适的数之前进行判断,输出:[[-1,0,1]] 。。。预期:[[-1,-1,2],[-1,0,1]],会发现,少了一个[-1,-1,2],当时我就蒙了。怎么回事呢?其实这样使得两个相同的数-1(位置k),-1(位置k+1)不能同时出现在解中,只要出现重复的数,就直接跳过,显然是错误的,不合题意的!
其实就是去重的时机不合适!应将其放在while(i < j)结束的后面(等把一个合适的三个取值加入list列表中在进行判断)。这样只是去除了第一个数取相同数(-1)的情况,无论第二三个数取什么。符合题意!
注意:这里的去重是while,而不是if!
根本原因还是逻辑与代码表达的逻辑一致。
b) 第二个级别的去重。上面第k位置去重之后,结果如下:
输入:[-2,0,0,2,2]
输出:[[-2,0,2],[-2,0,2]]
预期:[[-2,0,2]]
。当i指向0,j指向2 的时候,符合题意,开始的时候这里处理的逻辑并不是i++,j–;如何处理我也没找到方法。后来发现,这个是这样的:如果i值不变,j值前移,那么此时如果j仍指向2,重复,如果小于2了,那此时肯定不成立;同样,若j值不变,i值后移,若i仍指向0,虽符合计算,但重复,若不指向0,肯定会比0大,不符合计算!因此,只需要让i后移到一个不为0的值,让j前移到不为2的值即可。如果该位和下一位数相同,跳过!

共同点:先加入list一个成立的值,再去重。否则,可能会影响list中的结果。

C++代码:

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());

        for(int k=0;k<nums.size();k++){
            int i = k + 1;
            int j = nums.size() - 1;
            while(i < j){
                int value = nums[i] + nums[j];
                if(value > (0-nums[k])){
                    j--;
                }else if(value < 0-nums[k]){
                    i++;
                }else{
                    vector<int> list;
                    list.push_back(nums[k]);
                    list.push_back(nums[i]);
                    list.push_back(nums[j]);
                    res.push_back(list);
                    while(i<j && nums[i] == nums[i+1]){
                        i++;
                    }
                    while(i<j && nums[j] == nums[j-1]){
                        j--;
                    }
                    i++;
                    j--;
                }                
            }

            while(k<nums.size()-1 && nums[k] == nums[k+1]){
                    k++;
            }
        }
        return res;
    }
};
阅读更多
换一批

没有更多推荐了,返回首页