3Sum-LeetCode

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)

Solutions:

(1) Use Set to eliminate possible duplicates

(2) Start from the middle of the array and move to two ends to have O(N^2)

(3) Similar to 2Sum problem

Code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Vector;


public class ThreeSum {
	
	public static void main(String args[]){
		
		int[] s = {0,0,0,0,0,0};
		Arrays.sort(s);
		int first = 0;
		int size = s.length;
		int last = size-1;
		HashSet<Vector<Integer>> triplets = new HashSet<Vector<Integer>>();
		
		
		for(int i = 0; i < s.length; i++)
			while(last!=first&&last!=i&&first!=i){
			if(s[last]+s[first]+s[i]==0)
			{
				Integer[] arr = {};
				Vector<Integer> triplet = new Vector<Integer>(Arrays.asList(arr));
			
				  triplet.add(s[first]);
				  triplet.add(s[i]);
				  triplet.add(s[last]);
				  triplets.add(triplet);
				first++;
			}
			else if(s[last]+s[first]+s[i]<0)
				first++;
			else if(s[last]+s[first]+s[i]>0)
				last--;
			}
		ArrayList<Vector<Integer>> list = new ArrayList<Vector<Integer>>(triplets);
		
		System.out.println(list);
	}
	}

Others Better Solution:

public class Solution {
public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
	ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
 
	if (num.length < 3)
		return result;
 
	// sort array
	Arrays.sort(num);
 
	for (int i = 0; i < num.length - 2; i++) {
		// //avoid duplicate solutions
		if (i == 0 || num[i] > num[i - 1]) {
 
			int negate = -num[i];
 
			int start = i + 1;
			int end = num.length - 1;
 
			while (start < end) {
				//case 1
				if (num[start] + num[end] == negate) {
					ArrayList<Integer> temp = new ArrayList<Integer>();
					temp.add(num[i]);
					temp.add(num[start]);
					temp.add(num[end]);
 
					result.add(temp);
					start++;
					end--;
					//avoid duplicate solutions
					while (start < end && num[end] == num[end + 1])
						end--;
 
					while (start < end && num[start] == num[start - 1])
						start++;
				//case 2
				} else if (num[start] + num[end] < negate) {
					start++;
				//case 3
				} else {
					end--;
				}
			}
 
		}
	}
 
	return result;
}
}