LeetCode 15 -- 3Sum

Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target. Return the sum of the three integers. You may assume that each input would have exactly one solution.

For example, given array S = {-1 2 1 -4}, and target = 1. 
The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).

---

public class ThreeSum {
    public List<List<Integer>> threeSum(int[] nums){
        Arrays.sort(nums);
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0 ; i < nums.length ; i++){
            int leftPoint = i + 1;
            int rightPoint = nums.length - 1;
            while( leftPoint < rightPoint){
                if (nums[i] + nums[leftPoint] + nums[rightPoint] == 0){
                    list.add(nums[i]);
                    list.add(nums[leftPoint]);
                    list.add(nums[rightPoint]);
                    lists.add((ArrayList<Integer>) list);
                }
                    
                
                else if(nums[i] + nums[leftPoint] + nums[rightPoint] > 0 )
                    rightPoint--;
                else
                    leftPoint++;
            }
        }
        return lists;
    }
}

貌似没有考虑好边界问题，需要修改。超时了。

http://www.programcreek.com/2012/12/leetcode-3sum/

public class ThreeSum {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();

        if (nums.length < 3)
            return result;

        // sort array
        Arrays.sort(nums);

        for (int i = 0; i < nums.length - 2; i++) {
            // //avoid duplicate solutions
            if (i == 0 || nums[i] > nums[i - 1]) {

                int negate = -nums[i];

                int start = i + 1;
                int end = nums.length - 1;

                while (start < end) {
                    // case 1
                    if (nums[start] + nums[end] == negate) {
                        ArrayList<Integer> temp = new ArrayList<Integer>();
                        temp.add(nums[i]);
                        temp.add(nums[start]);
                        temp.add(nums[end]);

                        result.add(temp);
                        start++;
                        end--;
                        // avoid duplicate solutions
                        while (start < end && nums[end] == nums[end + 1])
                            end--;

                        while (start < end && nums[start] == nums[start - 1])
                            start++;
                        // case 2
                    } else if (nums[start] + nums[end] < negate) {
                        start++;
                        // case 3
                    } else {
                        end--;
                    }
                }

            }
        }

        return result;
    }
}

 http://stackoverflow.com/questions/10732522/difference-between-two-similar-algorithms-of-3sum

通过hashSet实现