moved again it into staging

Author: harshadunna

Java/algorithms/arrays/DutchNationalFlagProblem.java

@@ -0,0 +1,92 @@
+import java.util.Arrays;
+
+/**
+ * ## Dutch National Flag Problem (Sort Colors)
+ *
+ * This algorithm sorts an array containing only three distinct elements (0, 1, and 2) in-place.
+ * It's a classic partitioning problem that is solved in a single pass.
+ *
+ * ### How it works:
+ * 1. Use three pointers: `low`, `mid`, and `high`.
+ * 2. `low` points to the boundary of the '0' section.
+ * 3. `high` points to the boundary of the '2' section.
+ * 4. `mid` is the current element being considered.
+ * 5. If `nums[mid]` is 0, swap it with `nums[low]` and increment both `low` and `mid`.
+ * 6. If `nums[mid]` is 1, it's in the correct place, so just increment `mid`.
+ * 7. If `nums[mid]` is 2, swap it with `nums[high]` and decrement `high` (don't increment `mid` as the swapped element needs to be processed).
+ *
+ * ### Complexity
+ * - **Time Complexity:** O(n), where 'n' is the number of elements, because we iterate through the array only once.
+ * - **Space Complexity:** O(1), as the sorting is done in-place without using any extra data structures.
+ */
+public class DutchNationalFlagProblem {
+
+    public static void sortColors(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return;
+        }
+
+        int low = 0;
+        int mid = 0;
+        int high = nums.length - 1;
+
+        while (mid <= high) {
+            switch (nums[mid]) {
+                case 0:
+                    // When the element is 0, swap it with the element at the low pointer
+                    swap(nums, low, mid);
+                    low++;
+                    mid++;
+                    break;
+                case 1:
+                    // When the element is 1, it's in its correct place
+                    mid++;
+                    break;
+                case 2:
+                    // When the element is 2, swap it with the element at the high pointer
+                    swap(nums, mid, high);
+                    high--;
+                    // Do not increment mid, as the swapped element from high needs to be checked
+                    break;
+            }
+        }
+    }
+
+    private static void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+
+    /**
+     * Main method for testing the Dutch National Flag Problem implementation.
+     */
+    public static void main(String[] args) {
+        // Test Case 1: Mixed array
+        int[] colors1 = {2, 0, 2, 1, 1, 0};
+        System.out.println("Test Case 1:");
+        System.out.println("Original: " + Arrays.toString(colors1));
+        sortColors(colors1);
+        System.out.println("Expected: [0, 0, 1, 1, 2, 2]");
+        System.out.println("Actual:   " + Arrays.toString(colors1));
+        System.out.println();
+
+        // Test Case 2: Array is already sorted
+        int[] colors2 = {0, 0, 1, 2, 2};
+        System.out.println("Test Case 2:");
+        System.out.println("Original: " + Arrays.toString(colors2));
+        sortColors(colors2);
+        System.out.println("Expected: [0, 0, 1, 2, 2]");
+        System.out.println("Actual:   " + Arrays.toString(colors2));
+        System.out.println();
+
+        // Test Case 3: Array with only two kinds of elements
+        int[] colors3 = {2, 1, 1, 0, 0};
+        System.out.println("Test Case 3:");
+        System.out.println("Original: " + Arrays.toString(colors3));
+        sortColors(colors3);
+        System.out.println("Expected: [0, 0, 1, 1, 2]");
+        System.out.println("Actual:   " + Arrays.toString(colors3));
+        System.out.println();
+    }
+}

Java/algorithms/arrays/three_sum.java Java/algorithms/arrays/ThreeSum.javaJava/algorithms/arrays/three_sum.java renamed to Java/algorithms/arrays/ThreeSum.java

@@ -8,13 +8,18 @@
  * This algorithm finds all unique triplets in an array of integers that sum up to zero.
  * It uses a two-pointer approach on a sorted version of the array to efficiently find the triplets.
  *
+ * ### How it works:
+ * 1. The input array is sorted to enable the two-pointer approach and to handle duplicates easily.
+ * 2. We iterate through the array with a single pointer `i`.
+ * 3. For each element `nums[i]`, we use two more pointers, `left` (starting at `i+1`) and `right` (starting at the end of the array).
+ * 4. We calculate the sum of the three elements. If the sum is zero, we've found a triplet. If it's less than zero, we move `left` forward. If it's greater, we move `right` backward.
+ * 5. Duplicates are skipped to ensure that each unique triplet is only added once.
+ *
  * ### Complexity
- * - **Time Complexity:** O(n^2), where n is the number of elements in the array.
- * The array sort takes O(n log n), but the nested loop structure (one `for` loop and one `while` loop) dominates, resulting in O(n^2).
- * - **Space Complexity:** O(1), as we are not using any extra space other than for the output list.
- * The sorting is done in-place.
+ * - **Time Complexity:** O(n^2), where 'n' is the number of elements. The array sort is O(n log n), but the nested loop structure (a `for` loop and a `while` loop) dominates.
+ * - **Space Complexity:** O(1) for the algorithm itself (if we don't count the space for the output list). Sorting is done in-place.
  */
-public class three_sum {
+public class ThreeSum {
 
     public static List<List<Integer>> findTriplets(int[] nums) {
         // Sort the array to enable the two-pointer approach
@@ -23,68 +28,58 @@ public static List<List<Integer>> findTriplets(int[] nums) {
 
         // Iterate through the array. We only need to go up to the third-to-last element.
         for (int i = 0; i < nums.length - 2; i++) {
-            // Skip duplicate elements to avoid duplicate triplets in the result.
+            // Skip duplicate elements for the first element of the triplet to avoid duplicate results.
             if (i > 0 && nums[i] == nums[i - 1]) {
                 continue;
             }
 
-            // Use two pointers, one starting from the element after `i` and one from the end.
             int left = i + 1;
             int right = nums.length - 1;
-
             while (left < right) {
                 int currentSum = nums[i] + nums[left] + nums[right];
-
                 if (currentSum == 0) {
-                    // Found a triplet! Add it to the result.
                     result.add(Arrays.asList(nums[i], nums[left], nums[right]));
-
-                    // Move pointers and skip duplicates for the other two elements.
-                    while (left < right && nums[left] == nums[left + 1]) {
-                        left++;
-                    }
-                    while (left < right && nums[right] == nums[right - 1]) {
-                        right--;
-                    }
-
-                    // Move to the next unique pair.
+                    // 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 (currentSum < 0) {
-                    // If the sum is too small, move the left pointer to the right to increase it.
-                    left++;
+                    left++; // Sum is too small, need a larger number.
                 } else {
-                    // If the sum is too large, move the right pointer to the left to decrease it.
-                    right--;
+                    right--; // Sum is too large, need a smaller number.
                 }
             }
         }
         return result;
     }
 
     /**
-     * Main method for testing the three_sum implementation.
+     * Main method for testing the ThreeSum implementation.
      */
     public static void main(String[] args) {
-        // Test Case 1: Standard case with positive and negative numbers
+        // Test Case 1: Standard case with multiple solutions
         int[] nums1 = {-1, 0, 1, 2, -1, -4};
         System.out.println("Test Case 1:");
         System.out.println("Input: " + Arrays.toString(nums1));
-        System.out.println("Output: " + findTriplets(nums1)); // Expected: [[-1, -1, 2], [-1, 0, 1]]
+        System.out.println("Expected: [[-1, -1, 2], [-1, 0, 1]]");
+        System.out.println("Actual: " + findTriplets(nums1));
         System.out.println();
 
-        // Test Case 2: Array with all zeros
-        int[] nums2 = {0, 0, 0, 0};
+        // Test Case 2: Array with no solution
+        int[] nums2 = {1, 2, 3};
         System.out.println("Test Case 2:");
         System.out.println("Input: " + Arrays.toString(nums2));
-        System.out.println("Output: " + findTriplets(nums2)); // Expected: [[0, 0, 0]]
+        System.out.println("Expected: []");
+        System.out.println("Actual: " + findTriplets(nums2));
         System.out.println();
 
-        // Test Case 3: Array with no solution
-        int[] nums3 = {1, 2, 3, 4, 5};
+        // Test Case 3: Array with all zeros
+        int[] nums3 = {0, 0, 0, 0};
         System.out.println("Test Case 3:");
         System.out.println("Input: " + Arrays.toString(nums3));
-        System.out.println("Output: " + findTriplets(nums3)); // Expected: []
+        System.out.println("Expected: [[0, 0, 0]]");
+        System.out.println("Actual: " + findTriplets(nums3));
         System.out.println();
     }
 }