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.

For example, given array S = [-1, 0, 1, 2, -1, -4], A solution set is: [ [-1, 0, 1], [-1, -1, 2] ]

代码如下：算法复杂度O(n^2)

class Solution {
    
    public List<List<Integer>> threeSum(int[] num) {
        
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        if (num == null || num.length < 3) 
            return result;
        Arrays.sort(num);
        int lastNum = num[0] - 1;
        for (int i = 0; i < num.length - 2 && num[i] <= 0; i++) {
            if (num[i] != lastNum) {
                result.addAll(find(num, i));
                lastNum = num[i];
            }
        }
        return result;
    }

    private ArrayList<List<Integer>> find(int[] array, int index) {

        int i = index + 1;
        int j = array.length - 1;
        int lastI = array[index] - 1;
        int lastJ = array[index] - 1;

        ArrayList<List<Integer>> Lists = new ArrayList<List<Integer>>();

        while (i < j) {
            if (array[i] + array[j] + array[index] == 0) {
                if (array[i] == lastI) {
                    i++;
                } else if (array[j] == lastJ) {
                    j--;
                } else {
                    lastI = array[i];
                    lastJ = array[j];
                    ArrayList<Integer> curList = new ArrayList<Integer>();
                    curList.add(array[i]);
                    curList.add(array[j]);
                    curList.add(array[index]);
                    Lists.add(curList);
                    i++;
                    j--;
                }
            } else if (array[i] + array[j] + array[index] > 0) {
                j--;
            } else {
                i++;
            }
        }
        return Lists;
    }
}

注意几点：

1，如果遇到重复的数字，那么可以直接跳过。外层循环和内层循环都可以，因为都是排过序的，如果遇到同样的数字必然产生同样的结果。

2，具体实现的时候直接让lastNum等于开始的数字减一，保证第一个数字不会被跳过。

算法的核心思路是，首先排序。这个算法复杂度是O(n*logn)。接下来先依次找每一个数字，每找到一个数字，剩下的目标就是在剩下的数字中找到2个数，使他们之和为0。正因为排过序，所以找两个数字的过程算法复杂度可以下降到O(n)。也就是从两头往中间。每次如果和大于0，就说明在外层数字确定的情况下，这两个数字的和大了，也就要让其变小，让j--，反之则i++。