add java solutions upto QuickSort

Author: ashishps1

java/3Sum.md

@@ -1,2 +1,79 @@
-# 3Sum.md
+# [15. 3Sum](https://leetcode.com/problems/3sum/)
 
+## Approach 1: Brute Force (Basic)
+
+### Solution
+```java
+// Time Complexity: O(n^3)
+// Space Complexity: O(1) (excluding output list)
+import java.util.*;
+
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Set<List<Integer>> result = new HashSet<>();
+        int n = nums.length;
+
+        // Iterate through all possible triplets
+        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++) {
+                    if (nums[i] + nums[j] + nums[k] == 0) {
+                        List<Integer> triplet = Arrays.asList(nums[i], nums[j], nums[k]);
+                        Collections.sort(triplet); // Ensure the triplet is in sorted order
+                        result.add(triplet); // Add triplet to the set to avoid duplicates
+                    }
+                }
+            }
+        }
+
+        return new ArrayList<>(result); // Convert set to list for the output
+    }
+}
+```
+
+## Approach 2: Two Pointers (Optimal)
+
+### Solution
+```java
+// Time Complexity: O(n^2)
+// Space Complexity: O(n) (for sorting or output list)
+import java.util.*;
+
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Arrays.sort(nums); // Sort the array to use two-pointer technique
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            // Skip duplicates for the first element
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+
+            int left = i + 1;
+            int right = nums.length - 1;
+
+            // Two-pointer approach
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum == 0) {
+                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
+
+                    // Skip duplicates for the second and third elements
+                    while (left < right && nums[left] == nums[left + 1]) left++;
+                    while (left < right && nums[right] == nums[right - 1]) right--;
+
+                    left++;
+                    right--;
+                } else if (sum < 0) {
+                    left++; // Increase the sum
+                } else {
+                    right--; // Decrease the sum
+                }
+            }
+        }
+
+        return result;
+    }
+}
+```

java/add_two_numbers.md

@@ -1,2 +1,38 @@
-# add_two_numbers.md
+# [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/)
 
+## Approach: Iterative Solution with Carry
+
+### Solution
+```java
+// Time Complexity: O(max(m, n)), where m and n are the lengths of the two lists
+// Space Complexity: O(max(m, n)), for the new linked list
+public class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(0); // Dummy node to simplify the process
+        ListNode current = dummy; // Pointer to the current node in the result list
+        int carry = 0; // Store carry from the addition
+
+        // Traverse both lists
+        while (l1 != null || l2 != null || carry != 0) {
+            int sum = carry; // Start with the carry
+
+            // Add values from l1 and l2 if they exist
+            if (l1 != null) {
+                sum += l1.val;
+                l1 = l1.next;
+            }
+            if (l2 != null) {
+                sum += l2.val;
+                l2 = l2.next;
+            }
+
+            // Calculate new carry and the digit to store
+            carry = sum / 10;
+            current.next = new ListNode(sum % 10); // Store the last digit of the sum
+            current = current.next; // Move to the next node
+        }
+
+        return dummy.next; // Skip the dummy node
+    }
+}
+```

java/basic_calculator_2.md

@@ -1,2 +1,51 @@
-# basic_calculator_2.md
+# [227. Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/)
 
+## Approach: Using a Stack for Intermediate Results
+
+### Solution
+```java
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+import java.util.Stack;
+
+public class Solution {
+    public int calculate(String s) {
+        Stack<Integer> stack = new Stack<>();
+        int currentNumber = 0;
+        char operation = '+'; // Default operation is addition
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            // Build the current number
+            if (Character.isDigit(c)) {
+                currentNumber = currentNumber * 10 + (c - '0');
+            }
+
+            // Process operators and the last number
+            if (!Character.isDigit(c) && c != ' ' || i == s.length() - 1) {
+                if (operation == '+') {
+                    stack.push(currentNumber);
+                } else if (operation == '-') {
+                    stack.push(-currentNumber);
+                } else if (operation == '*') {
+                    stack.push(stack.pop() * currentNumber);
+                } else if (operation == '/') {
+                    stack.push(stack.pop() / currentNumber);
+                }
+
+                operation = c; // Update the operation
+                currentNumber = 0; // Reset the current number
+            }
+        }
+
+        // Sum up all the values in the stack
+        int result = 0;
+        while (!stack.isEmpty()) {
+            result += stack.pop();
+        }
+
+        return result;
+    }
+}
+```

java/construct_quad_tree.md

@@ -1,2 +1,39 @@
-# construct_quad_tree.md
+# [427. Construct Quad Tree](https://leetcode.com/problems/construct-quad-tree/)
 
+## Approach 1: Recursive Division of Grid
+
+### Solution
+```java
+// Time Complexity: O(n^2 * log n), where n is the side length of the grid
+// Space Complexity: O(log n) (due to recursion stack)
+public class Solution {
+    public Node construct(int[][] grid) {
+        return buildTree(grid, 0, 0, grid.length);
+    }
+
+    private Node buildTree(int[][] grid, int x, int y, int size) {
+        if (size == 1) {
+            // Base case: single cell
+            return new Node(grid[x][y] == 1, true, null, null, null, null);
+        }
+
+        int halfSize = size / 2;
+
+        // Recursively divide the grid into four quadrants
+        Node topLeft = buildTree(grid, x, y, halfSize);
+        Node topRight = buildTree(grid, x, y + halfSize, halfSize);
+        Node bottomLeft = buildTree(grid, x + halfSize, y, halfSize);
+        Node bottomRight = buildTree(grid, x + halfSize, y + halfSize, halfSize);
+
+        // Check if all four quadrants are leaves with the same value
+        if (topLeft.isLeaf && topRight.isLeaf && bottomLeft.isLeaf && bottomRight.isLeaf
+                && topLeft.val == topRight.val && topRight.val == bottomLeft.val
+                && bottomLeft.val == bottomRight.val) {
+            return new Node(topLeft.val, true, null, null, null, null); // Merge into one leaf
+        }
+
+        // Otherwise, create an internal node
+        return new Node(true, false, topLeft, topRight, bottomLeft, bottomRight);
+    }
+}
+```

java/container_with_most_water.md

@@ -1,2 +1,56 @@
-# container_with_most_water.md
+# [11. Container With Most Water](https://leetcode.com/problems/container-with-most-water/)
 
+## Approach 1: Brute Force
+
+### Solution
+```java
+// Time Complexity: O(n^2)
+// Space Complexity: O(1)
+public class Solution {
+    public int maxArea(int[] height) {
+        int maxArea = 0;
+
+        // Check all pairs of lines
+        for (int i = 0; i < height.length; i++) {
+            for (int j = i + 1; j < height.length; j++) {
+                // Calculate the area for the current pair of lines
+                int area = Math.min(height[i], height[j]) * (j - i);
+                maxArea = Math.max(maxArea, area); // Update max area if needed
+            }
+        }
+
+        return maxArea;
+    }
+}
+```
+
+## Approach 2: Two Pointers (Optimal)
+
+### Solution
+```java
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+public class Solution {
+    public int maxArea(int[] height) {
+        int left = 0; // Start pointer
+        int right = height.length - 1; // End pointer
+        int maxArea = 0; // Initialize max area
+
+        // Iterate until the two pointers meet
+        while (left < right) {
+            // Calculate the current area
+            int area = Math.min(height[left], height[right]) * (right - left);
+            maxArea = Math.max(maxArea, area); // Update max area if needed
+
+            // Move the pointer pointing to the shorter line
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return maxArea;
+    }
+}
+```

java/contiguous_array.md

@@ -1,2 +1,64 @@
-# contiguous_array.md
+# [525. Contiguous Array](https://leetcode.com/problems/contiguous-array/)
 
+## Approach 1: Brute Force (Basic)
+
+### Solution
+```java
+// Time Complexity: O(n^2)
+// Space Complexity: O(1)
+public class Solution {
+    public int findMaxLength(int[] nums) {
+        int maxLength = 0;
+
+        // Check all possible subarrays
+        for (int i = 0; i < nums.length; i++) {
+            int count = 0;
+
+            for (int j = i; j < nums.length; j++) {
+                // Increment or decrement count based on value
+                count += nums[j] == 1 ? 1 : -1;
+
+                // If count is zero, it means equal number of 0s and 1s
+                if (count == 0) {
+                    maxLength = Math.max(maxLength, j - i + 1);
+                }
+            }
+        }
+
+        return maxLength;
+    }
+}
+```
+
+## Approach 2: HashMap (Optimal)
+
+### Solution
+```java
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+import java.util.HashMap;
+
+public class Solution {
+    public int findMaxLength(int[] nums) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        map.put(0, -1); // Initialize with a count of 0 at index -1
+        int maxLength = 0;
+        int count = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            // Increment or decrement count based on value
+            count += nums[i] == 1 ? 1 : -1;
+
+            if (map.containsKey(count)) {
+                // Calculate the length of the subarray
+                maxLength = Math.max(maxLength, i - map.get(count));
+            } else {
+                // Store the first occurrence of this count
+                map.put(count, i);
+            }
+        }
+
+        return maxLength;
+    }
+}
+```