Update three sum algorithm

Author: sudheerj

src/java1/algorithms/array/ThreeSum.java

@@ -0,0 +1,37 @@
+package threeSum;
+import java.util.*;
+
+public class ThreeSum {
+    // Two pointer approach:- TC: O(n logn) + O(n*2) => O(n * 2), SC: O(1)
+    private static List<List<Integer>> threeSum(int[] nums, int target) {
+        Arrays.sort(nums);
+        List<List<Integer>> triplets = new ArrayList<>();
+
+        for(int i=0; i < nums.length-2; i++) {
+                if(i > 0 && nums[i] == nums[i-1]) continue;
+                
+                int left = i + 1, right = nums.length-1;
+
+                while(left < right) {
+                    int sum = nums[left] + nums[right] + nums[i] ;
+                    if(sum < target) {
+                        left++;
+                    } else if (sum > target) {
+                        right--;
+                    }
+                    else {
+
+                        triplets.add(List.of(nums[i], nums[left], nums[right]));
+                        left++;
+                        while(left < right && nums[left] == nums[left-1]) left++;
+                    } 
+                }
+        }
+        return triplets;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {3, 3, -1, -2, 0, -2, 0, -1, 0, -1};
+        System.out.println(threeSum(nums, 0));
+    }
+}

src/java1/algorithms/array/threeSum/ThreeSum.java

@@ -0,0 +1,27 @@
+package threeSumDuplicates;
+import java.util.*;
+
+// Hashing:- TC: O(n logn) + O(n*2) => O(n * 2), SC: O(n)
+public class ThreeSumDuplicates {
+    private static List<List<Integer>> threeSum(int[] nums, int target) {
+        List<List<Integer>> triplets = new ArrayList<>();
+        HashSet<Integer> hashset = new HashSet<>();
+
+        for(int i=0; i< nums.length-2; i++) {
+            for(int j=i+1; j< nums.length-1; j++) {
+                int complement = target -(nums[i]+nums[j]);
+                if(hashset.contains(complement) && !triplets.contains(List.of(nums[i], nums[j], complement))) {
+                    triplets.add(List.of(nums[i], nums[j], complement));
+                } else {
+                    hashset.add(nums[j]);
+                }
+            }
+        }
+        return triplets;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {3, 3, -1, -2, 0, -2, 0, -1, 0, -1};
+        System.out.println(threeSum(nums, 0));
+    }
+}

src/java1/algorithms/array/threeSum/ThreeSum.md

@@ -0,0 +1,31 @@
+// Two pointer approach:- TC: O(n logn) + O(n^2) => O(n^2), SC: O(1)
+function threeSum(nums, target) {
+    nums.sort((a, b) => a-b);
+    let triplets = [];
+
+    for(let i = 0; i < nums.length -2; i++) {
+        //It avoids duplicates
+        if(i > 0 && nums[i] === nums[i-1]) continue;
+
+        let left = i+1, right = nums.length -1;
+        while(left < right) {
+            let sum = nums[i] + nums[left] + nums[right];
+            if(sum < target) {
+                left++;
+            } else if(sum > target) {
+                right--;
+            } else {
+                triplets.push([nums[i], nums[left], nums[right]]);
+                left++;
+                //It avoids duplicates
+                while(left < right && nums[left] === nums[left-1]) left++;
+            }
+        }
+    }
+    return triplets;
+}
+
+let nums1 = [3, 3, -1, -2, 0, -2, 0, -1, 0, -1];
+let nums2 = [1, 3, 5, 1];
+console.log(threeSum(nums1, 0));
+console.log(threeSum(nums2, 0));

src/java1/algorithms/array/threeSumDuplicates/ThreeSumDuplicates.java

@@ -0,0 +1,17 @@
+**Description:**
+Given an array of integers, return an array of triplets (in any order) such that `i != j != k` and `nums[i] + nums[j] + nums[k] = 0`. 
+
+Note that the solution set must not include duplicate triplets (i.e., [1, 0, 0] and [0, 1, 0] are duplicative).
+
+## Examples:
+Example 1
+Input: [-1,0,1,2,-1,-4] 
+Output: [[-1,-1,2],[-1,0,1]]
+
+Example 2
+Input: [1,4,5,1] 
+Output: []
+
+Example 3
+Input: [0,0,0] 
+Output: [[0,0,0]]

src/javascript/algorithms/array/threeSum.js

@@ -0,0 +1,21 @@
+// Hashing:- TC: O(n logn) + O(n^2) => O(n^2), SC: O(n)
+function threeSumHashing(nums, target) {
+    let triplets = [];
+    let tripletSet = new Set();
+    for(let i =0; i < nums.length - 2; i++) {
+        for(let j=i+1; j< nums.length - 1; j++) {
+            let complement = target - (nums[i] + nums[j]);
+            if(tripletSet.has(complement)) {
+                triplets.push([nums[i], nums[j], complement]);
+            } else {
+                tripletSet.add(nums[j]);
+            }
+        }
+    }
+    return triplets;
+}
+
+let nums1 = [1, 2, 3, 4, 5, 6, 7, 8];
+let nums2 = [-1,0,1,2,-1,-4];
+console.log(threeSumHashing(nums1, 9));
+console.log(threeSumHashing(nums2, 0));