Two-pointer-1 Home Work

ContainerWithMostWater.java

@@ -0,0 +1,41 @@
+public class ContainerWithMostWater {
+    public static void main(String args[]){
+        //int [] arr = {1,8,6,2,5,4,8,3,7};
+        int [] arr ={2,5,3,8,10,6,12,10};
+        System.out.println(maxArea(arr));
+    }
+
+    public static int maxArea(int[] height) {
+        /*
+        //Brute-force approach
+        int n = height.length;
+        int maxArea = 0;
+        for(int i =0; i<n; i++){ //O(n)
+            for(int j=i+1; j<n; j++){ //O(n) --> total time complexity O(n^2)
+                int currArea = Math.min(height[i], height[j]) * (j-i);
+                maxArea = Math.max(maxArea,currArea);
+            }
+        }
+         */
+
+        //two-pointer approach
+        int n = height.length;
+        int maxArea = 0;
+        int left = 0;
+        int right = n-1;
+        while(left<right){ //O(n)
+            int currArea = Math.min(height[left],height[right]) * (right - left);
+            maxArea = Math.max(maxArea, currArea);
+            if(height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return maxArea;
+    }
+
+}
+
+//Time complexity : O(n)
+//Space complexity : O(1)

SortColors.java

@@ -0,0 +1,38 @@
+import java.util.Arrays;
+public class SortColors {
+    public void sortColors(int[] nums) {
+        int n =  nums.length;
+        int left = 0;
+        int right = n-1;
+        int mid = 0;
+        while(mid <= right){ //O(n)
+            if(nums[mid] == 2){
+                swap(nums, mid, right);
+                right --;
+            } else if(nums[mid] == 0){
+                swap(nums, mid, left);
+                left++;
+                mid++;
+            } else {
+                mid++;
+            }
+        }
+    }
+    private void swap(int[] nums, int i, int j){
+        int temp = nums[i];
+        nums[j] = nums[i];
+        nums[i] = temp;
+    }
+
+    public static void main(String[] args) {
+        int[] arr2 = {0,0,2,1,1,0,0,1,2,2};
+
+        SortColors sc = new SortColors();
+        sc.sortColors(arr2);
+
+        System.out.println(Arrays.toString(arr2));
+    }
+}
+
+//Time complexity : O(n)
+//Space complexity : O(1)

ThreeSum.java

@@ -0,0 +1,57 @@
+import java.util.*;
+
+public class ThreeSum {
+    public static List<List<Integer>> threeSum(int[] nums) {
+        int n = nums.length;
+        //Condition to check if length of array less than 3 or if its empty
+        if (nums == null || n < 3) return new ArrayList<>();
+
+        //Step 1: Sort the elements in array
+        Arrays.sort(nums);
+        Set<List<Integer>> result = new HashSet<>();
+        //Step 2: Using Two-pointer approach
+        //Fix position of first element i.e. nums[i], traverse until < n-2 as we need triplets in end
+        for (int i = 0; i < n - 2; i++) { //0(n)
+            int l = i + 1;
+            int r = n - 1;
+            while (l < r) {   //0(n)
+                int sum = nums[i] + nums[l] + nums[r];
+                if (sum == 0) {
+                    //Add the set and move to find other triplets, increment left and decrement right
+                    result.add(Arrays.asList(nums[i], nums[l], nums[r]));
+                    l++;
+                    r--;
+                } else if (sum < 0) {
+                    l++;
+                } else {
+                    r--;
+                }
+            }
+        }
+        return new ArrayList<>(result);
+    }
+        /*
+        //Brute-force approach
+        for(int i=0; i<n-2;i++){
+            for(int j=i+1;j<n-1;j++){
+                for(int k=j+1;k<n;k++){
+                    int sum = nums[i] + nums[j] + nums[k];
+                    if(sum==0){
+                        result.add(Arrays.asList(nums[i],nums[j],nums[k]));
+                    }
+                }
+            }
+        }
+
+        return new ArrayList<>(result);
+    }
+    */
+
+    public static void main(String args[]){
+        int [] arr1 ={-1,0,1,2,-1,-4};
+        System.out.println(threeSum(arr1));
+    }
+}
+
+//Time complexity : 0(n^2)
+//Space complexity : O(n)

out/production/Two-Pointers-1/README.md

@@ -0,0 +1,8 @@
+# Two-Pointers-1
+
+## Problem1 (https://leetcode.com/problems/sort-colors/)
+
+## Problem2 (https://leetcode.com/problems/3sum/)
+
+## Problem3 (https://leetcode.com/problems/container-with-most-water/)
+