Leetcode热题100(Leetcode_15)-三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

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

 

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
 

我的解法和leetcode上的大多数题解的思想是不一样的，leetcode上题解的思想大多是采用双指针法来遍历查询和为0的值，然后通过类似这种操作的方式来实现去重，如下图

这是leetcode题解中java排行第一的解法，出自大佬之手，代码确实很优雅，但是我却实在看不懂为啥这样就能做到去重了，于是乎，我还是采用自己的老方法来解这题，首先尝试了n3的解法，如下：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //先排序
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        List<String> strs = new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            for(int j=i+1;j<nums.length;j++){
                for(int k=j+1;k<nums.length;k++){
                    if((nums[i]+nums[j]+nums[k])==0){
                        List<Integer> l = new ArrayList<>();
                        l.add(nums[i]);
                        l.add(nums[j]);
                        l.add(nums[k]);
                        String str = nums[i]+""+nums[j]+""+nums[k];
                        if(!strs.contains(str)) {
                            list.add(l);
                            strs.add(str);
                        }
                    }
                }
            }
        }
        return list;
    }
}

果不其然，我超时了...........

于是采用传统艺能，用空间换时间，由于最近在看JVM内部实现原理的书籍，所以对于空间换时间的方式非常感兴趣，于是采用了类似GC垃圾收集时用来记忆跨代引用的记忆集的类似方式，建立了一个我自己的记忆集，用于记录各个元素出现的数量（采用一个int数组实现）。这样就避免了三重循环，而是可以将时间复杂度控制在n²，在寻找第三个数的时候，可以直接通过记忆集索引获得我们所需要的数是否存在，详细代码如下图

import java.util.*;
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //先排序
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        if(nums.length==0)
            return list;
        List<String> strs = new ArrayList<>();
        int maxLength = Math.max(Math.abs(nums[nums.length-1]),Math.abs(nums[0]));
        int[] flag1 = new int[maxLength+1];
        for(int t:nums){
            if(t>=0)
                flag1[t] = flag1[t]+1;
        }
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0)
                break;
            if(i!=0&&nums[i]==nums[i-1]) continue;
            for(int j=i+1;j<nums.length;j++){
                int need = -nums[i]-nums[j];
                List<Integer> l = new ArrayList<>();
                l.add(nums[i]);
                l.add(nums[j]);
                l.add(need);
                l.sort(Comparator.naturalOrder());
                String str = l.get(0)+""+l.get(1)+""+l.get(2);
                if(Math.abs(need)>maxLength)
                    continue;
                if(need>=0){
                    int needNum = 1;
                    if(nums[i]==need)
                        needNum++;
                    if(nums[j]==need)
                        needNum++;
                    if(flag1[need]>=needNum
                            &&!strs.contains(str)
                    ){
                        list.add(l);
                        strs.add(str);
                    }
                }
            }
        }
        return list;
    }
}

这样做之后，在我本地测试下，最长的用例耗时也能控制在两秒以内，但是放到leetcode上执行还是超时了，我想到可能是去重时的时间复杂度太高了，于是我将问题定位到我采用list来存放拼接的字符串来去重，list的contains方法效率不高。于是我最终想到了利用set进行去重，成功通过！代码如下：

import java.util.*;
class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        //先排序
        Arrays.sort(nums);
        List<List<Integer>> list = new ArrayList<>();
        if(nums.length==0)
            return list;
        Set<String> strs = new HashSet<>();
        int maxLength = Math.max(Math.abs(nums[nums.length-1]),Math.abs(nums[0]));
        int[] flag1 = new int[maxLength+1];
        for(int t:nums){
            if(t>=0)
                flag1[t] = flag1[t]+1;
        }
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0)
                break;
            if(i!=0&&nums[i]==nums[i-1]) continue;
            for(int j=i+1;j<nums.length;j++){
                int need = -nums[i]-nums[j];
                List<Integer> l = new ArrayList<>();
                l.add(nums[i]);
                l.add(nums[j]);
                l.add(need);
                l.sort(Comparator.naturalOrder());
                String str = l.get(0)+""+l.get(1)+""+l.get(2);
                if(Math.abs(need)>maxLength)
                    continue;
                if(need>=0){
                    int needNum = 1;
                    if(nums[i]==need)
                        needNum++;
                    if(nums[j]==need)
                        needNum++;
                    if(flag1[need]>=needNum
                            &&!strs.contains(str)
                    ){
                        list.add(l);
                        strs.add(str);
                    }
                }
            }
        }
        return list;
    }
}

由此我不得不感叹，Set去重万岁，Hash是人类算法伟大的发明！采用HashSet去重后，算法消耗时间变为原来的一半了，直接！可见list.contains和set.contains之间的差距！