3Sum

原题：

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.

即从给定数组中找到和为零的三个数，找出所有情况且不能重复！

思考过程：

这道题我做了两天。很多时候当我对一个题有思路的时候是不愿意看别人的答案的，我想用我的思路把它做下来。从小遇到的老师有的说我犟，有的说我能独立思考。往往我容易进入弯路，耗费比正常人更长的时间，比较少的时候我找到了捷径，但结果是我能把思想、思维学到骨子里。

首先我想到的是延伸twoSum的思想，把它从二维变成三维，一开始是先把两个数加起来，再去hasmap里找第三个数，，结果是都能找出来，但是总避免不了重复。后来打算看看别人的思路，有人说到一句threeSum就是遍历整个数组，对每个元素调用twoSum函数，找到结果。fourSum同理。我觉得很有道理，kSum也能做出来。很容易实现这个函数，但是重复结果依旧难以消除，最后我对结果进行排除重复处理，实现功能，leetCode说超时了。我觉得虽然是麻烦了点，但时间复杂度还是o(n^2)的，排除重复代码如下：

for (int i = 0;i < res.size() - 1;i++)//以前用于处理res重复元素的算法，会超时。
    for (int j = i+1;j < res.size();j++)
        if (res.get(i).equals(res.get(j))){
            res.remove(j);j--;
        }

当然之前我都做过处理，所有满足题意的集合元素都从小到大排列。

后来没办法去搜，看到了双指针算法：先排序，再从两边往中间找结果。看到了另一番景象。我写出了如下方法：

public List<List<Integer>> threeSum(int[] nums){
    Arrays.sort(nums);
    List<List<Integer>> res = new ArrayList<>();
    res = twoSum(nums,1,0 - nums[0]);//提前处理，防止i = 0 时候数组越界
    for (int i = 1;i < nums.length - 2;i++){
        while (((nums[i] == nums[i - 1]) && (i < nums.length))) continue;//去掉重复，但一连串重复数字的第一个是必须调用一下twoSum的，比如-1，-1，2这种情况
        res.addAll(twoSum(nums,i + 1,0 - nums[i]));
    }
    return res;
}
public List<List<Integer>> twoSum(int[] nums,int begin,int target){
    List<List<Integer>> integers = new ArrayList<>();
    int l = begin,r = nums.length - 1;
    while (l < r){
        while ((l < r) && (l > 0) && (nums[l] == nums[l-1])) continue;
        while ((l < r) && (r < nums.length - 1) && (nums[r] == nums[r + 1])) continue;//处理重复
        int total = nums[l] + nums[r];
        if (total > target) r--;
        if (total < target) l++;
        if (total == target){
            List<Integer> ints = new ArrayList<>();
            ints.add(nums[begin - 1]);
            ints.add(nums[l]);
            ints.add(nums[r]);
            integers.add(ints);
            l++;r--;
        }
    }return integers;
}

时间复杂度是o(n^2）,但依旧显示超时。和我参考的博客思路是一样的，代码甚至差别都不大，那个博客的就过了，转载一下：

https://segmentfault.com/a/1190000003740669

博主代码：

public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums);
    ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
    for(int i = 0; i < nums.length - 2; i++){
        // 跳过重复元素
        if(i > 0 && nums[i] == nums[i-1]) continue;
        // 计算2Sum
        ArrayList<List<Integer>> curr = twoSum(nums, i, 0 - nums[i]);
        res.addAll(curr);
    }
    return res;
}

private ArrayList<List<Integer>> twoSum(int[] nums, int i, int target){
    int left = i + 1, right = nums.length - 1;
    ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
    while(left < right){
        if(nums[left] + nums[right] == target){
            ArrayList<Integer> curr = new ArrayList<Integer>();
            curr.add(nums[i]);
            curr.add(nums[left]);
            curr.add(nums[right]);
            res.add(curr);
            do {
                left++;
            }while(left < nums.length && nums[left] == nums[left-1]);
            do {
                right--;
            } while(right >= 0 && nums[right] == nums[right+1]);
        } else if (nums[left] + nums[right] > target){
            right--;
        } else {
            left++;
        }
    }
    return res;
}