[LeetCode] 015--3Sum --Medium--

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:
Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
The solution set must not contain duplicate triplets.
For example, given array S = {-1 0 1 2 -1 -4},

A solution set is:
(-1, 0, 1)
(-1, -1, 2)

提示 Array Two Pointers
类似题目 (M) Two Sum (M) 3Sum Closest (M) 4Sum (M) 3Sum Smaller

原题链接：https://leetcode.com/problems/3sum/

大概意思是：给出一个整型数组，求出所有和为0的三个数。要求，1数字顺序小到大；2不允许重复
思路：跟上一道题TwoSum的思路一样，排序然后两边向中间夹逼。

解题语言：java
方法一 双向指针，时间复杂度O(nlogn+n+n+a*b+a*b)=O(a*b），其中a、b分别为正数、负数的个数

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<Integer> pos = new ArrayList<Integer>();
        List<Integer> neg = new ArrayList<Integer>();
        List<Integer> zoer = new ArrayList<Integer>();
        // Arrays.sort(nums)
        List<List<Integer>> threeSumAll = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2) {
            return threeSumAll;
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < 0) {
                neg.add(nums[i]);
            } else if (nums[i] == 0) {
                zoer.add(0);
            } else {
                pos.add(nums[i]);
            }
        }
        Collections.sort(neg);
        Collections.sort(zoer);
        Collections.sort(pos);
        // System.out.println("neg.toString():::" + neg.toString());
        // System.out.println("zoer.toString():::" + zoer.toString());
        // System.out.println("pos.toString():::" + pos.toString());
        // 包含0的情况
        if (zoer.size() > 0) {
            List<Integer> oneList = new ArrayList<Integer>(neg);
            oneList.addAll(pos);
            System.out.println("oneList.toString():::" + oneList.toString());

            int left, right;
            left = 0;
            right = oneList.size() - 1;
            while (left < right) {
                if (oneList.get(left) + oneList.get(right) == 0) {
                    if (left + 1 < right - 1
                            && oneList.get(left) == oneList.get(left + 1)
                            && oneList.get(right) == oneList.get(right - 1)) {
                        left = left + 1;
                        right = right - 1;
                        continue;
                    }
                    // else{
                    List<Integer> threeSum = new ArrayList<Integer>();
                    threeSum.add(oneList.get(left));
                    threeSum.add(0);
                    threeSum.add(oneList.get(right));
                    threeSumAll.add(threeSum);
                    left = left + 1;
                    right = right - 1;
                    // }

                } else if (oneList.get(left) + oneList.get(right) < 0) {
                    left = left + 1;
                } else {
                    right = right - 1;
                }
            }
            // 特殊情况包含3个0
            if (zoer.size() > 2) {
                List<Integer> threeSum = new ArrayList<Integer>();
                threeSum.add(0);
                threeSum.add(0);
                threeSum.add(0);
                threeSumAll.add(threeSum);
            }
        }

//      计算一个正数，两个负数的情况
        for (int i = 0; i < pos.size(); i++) {
            if (i + 1 < pos.size() && pos.get(i) == pos.get(i + 1)) {
                continue;
            }
            int positive = pos.get(i);
            int left, right;
            left = 0;
            right = neg.size() - 1;
            int Negative = Integer.MAX_VALUE;
            while (left < right) {
                if (neg.get(left) + neg.get(right) + positive == 0
                        && Negative != neg.get(left)) {
                    // System.out.println("neg.get(left):::"
                    // + neg.get(left));
                    // System.out.println("neg.get(right):::"
                    // + neg.get(right));
                    // System.out.println("Negative:::" + Negative);
                    List<Integer> threeSum = new ArrayList<Integer>();
                    threeSum.add(neg.get(left));
                    threeSum.add(neg.get(right));
                    threeSum.add(positive);
                    threeSumAll.add(threeSum);
                    Negative = neg.get(left);
                    left = left + 1;
                    right = right - 1;
                } else if (neg.get(left) + neg.get(right)
                        + positive < 0) {
                    left = left + 1;
                } else {
                    right = right - 1;
                }
            }
        }

//      计算一个负数，两个正数的情况
        for (int i = 0; i < neg.size(); i++) {
            if (i + 1 < neg.size() && neg.get(i) == neg.get(i + 1)) {
                continue;
            }
            int negative = neg.get(i);
            int left, right;
            left = 0;
            right = pos.size() - 1;
            int Positive = Integer.MAX_VALUE;
            while (left < right) {
                if (pos.get(left) + pos.get(right) + negative == 0
                        && Positive != pos.get(left)) {
                    List<Integer> threeSum = new ArrayList<Integer>();
                    threeSum.add(negative);
                    threeSum.add(pos.get(left));
                    threeSum.add(pos.get(right));
                    threeSumAll.add(threeSum);
                    Positive = pos.get(left);
                    left = left + 1;
                    right = right - 1;
                } else if (pos.get(left) + pos.get(right) + negative < 0) {
                    left = left + 1;
                } else {
                    right = right - 1;
                }
            }
        }
        return threeSumAll;
    }

}

方法二：
csdn的一个大神解答，思路，使用排序之后夹逼的方法，总的时间复杂度为O(n^2+nlogn)=(n^2),空间复杂度是O(n),代码简介清晰，赞！！！
这里上原链接：http://blog.csdn.net/linhuanmars/article/details/19711651

public class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
        if (nums == null || nums.length <= 2)
            return res;
        Arrays.sort(nums);
        for (int i = nums.length - 1; i >= 2; i--) {
            if (i < nums.length - 1 && nums[i] == nums[i + 1])
                continue;
            ArrayList<List<Integer>> curRes = twoSum(nums, i - 1, -nums[i]);
            for (int j = 0; j < curRes.size(); j++) {
                curRes.get(j).add(nums[i]);
            }
            res.addAll(curRes);
        }
        return res;

    }

    private ArrayList<List<Integer>> twoSum(int[] num, int end, int target) {
        ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
        if (num == null || num.length <= 1)
            return res;
        int l = 0;
        int r = end;
        while (l < r) {
            if (num[l] + num[r] == target) {
                ArrayList<Integer> item = new ArrayList<Integer>();
                item.add(num[l]);
                item.add(num[r]);
                res.add(item);
                l++;
                r--;
                while (l < r && num[l] == num[l - 1])
                    l++;
                while (l < r && num[r] == num[r + 1])
                    r--;
            } else if (num[l] + num[r] > target) {
                r--;
            } else {
                l++;
            }
        }
        return res;
    }
}

对比了一下两者，其实方法二耗时在10ms左右，方法一40ms上下。