Fixed complexity analysis and added good pivot condition for 3way

Author: kaitinghh

out/production/src/src/dataStructures/disjointSet/quickFind/quick_find.iml

@@ -10,8 +10,8 @@
  * QuickSort is a divide-and-conquer sorting algorithm. The basic idea behind Quicksort is to choose a pivot element,
  * places it in its correct position in the sorted array, and then recursively sorts the sub-arrays on either side of
  * the pivot. When we introduce randomization in pivot selection, every element has equal probability of being
- * selected as the pivot. This means the chance of the smallest or largest element getting chosen as the pivot is
- * decreased, so we reduce the probability of encountering the worst-case scenario.
+ * selected as the pivot. This means the chance of an extreme element getting chosen as the pivot is decreased, so we
+ * reduce the probability of encountering the worst-case scenario of imbalanced partitioning.
  *
  * Implementation Invariant:
  * The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
@@ -22,9 +22,9 @@
  *
  * Complexity Analysis:
  * Time:
- * - Worst case (poor choice of pivot): O(n^2)
- * - Average case: O(nlogn)
- * - Best case (balanced pivot): O(nlogn)
+ * - Expected worst case (poor choice of pivot): O(n^2)
+ * - Expected average case: O(nlogn)
+ * - Expected Best case (balanced pivot): O(nlogn)
  *
  * In the best case of a balanced pivot, the partitioning process divides the array in half, which leads to log n
  * levels of recursion. Given a sub-array of length m, the time complexity of the partition subroutine is O(m) as we
@@ -34,10 +34,6 @@
  * Even in the average case where the chosen pivot partitions the array by a fraction, there will still be log n levels
  * of recursion. (e.g. T(n) = T(n/10) + T(9n/10) + O(n) => O(nlogn))
  *
- * In the worst case where the pivot selected is consistently the smallest or biggest element in the array, the
- * partitioning of the array around the pivot will be extremely unbalanced, leading to a recurrence relation of:
- * T(n) = T(n-1) + O(n) => O(n^2). We have reduced the likelihood of this happening by randomising pivot selection.
- *
  * However, if there are many duplicates in the array, e.g. {1, 1, 1, 1}, the 1st pivot will be placed in the 3rd idx,
  * and 2nd pivot in 2nd idx, 3rd pivot in the 1st idx and 4th pivot in the 0th idx. As we observe, the presence of many
  * duplicates in the array leads to extremely unbalanced partitioning, leading to a O(n^2) time complexity.

src/algorithms/sorting/quickSort/lomuto/QuickSort.java

@@ -9,23 +9,23 @@
  * This is basically Lomuto's QuickSort, with an additional check to guarantee a good pivot.
  *
  * Complexity Analysis:
- * Time:
- * - Worst case: does not terminate
- * - Average case: O(nlogn)
- * - Best case: O(nlogn)
+ * Time: (this analysis assumes the absence of many duplicates in our array)
+ * - Expected worst case: O(nlogn)
+ * - Expected average case: O(nlogn)
+ * - Expected best case: O(nlogn)
  *
- * The additional check to guarantee a good pivot guards against the worst case scenario where the chosen pivot is
- * the smallest or biggest element in the array, leading to an extremely unbalanced partitioning. Since the chosen
- * pivot has to at least partition the array into a 1/10, 9/10 split, the recurrence relation will be:
- * T(n) = T(n/10) + T(9n/10) + n(# iterations of pivot selection).
+ * The additional check to guarantee a good pivot guards against the worst case scenario where the chosen pivot results
+ * in an extremely imbalanced partitioning. Since the chosen pivot has to at least partition the array into a
+ * 1/10, 9/10 split, the recurrence relation will be: T(n) = T(n/10) + T(9n/10) + n(# iterations of pivot selection).
  *
  * The number of iterations of pivot selection is expected to be <2 (more precisely, 1.25). This is because
  * P(good pivot) = 8/10. Expected number of tries to get a good pivot = 1 / P(good pivot) = 10/8 = 1.25.
  *
- * Therefore, the average time-complexity is: T(n) = T(n/10) + T(9n/10) + 1.25n => O(nlogn).
+ * Therefore, the expected time-complexity is: T(n) = T(n/10) + T(9n/10) + 1.25n => O(nlogn).
  *
- * However, the presence of this additional check and repeating pivot selection means that if we have an array of
- * length n >= 10 containing all duplicates of the same number, any pivot we pick will be a bad pivot and we will
+ * Edge case: does not terminate
+ * The presence of this additional check and repeating pivot selection means that if we have an array of
+ * length n >= 10 containing all/many duplicates of the same number, any pivot we pick will be a bad pivot and we will
  * enter an infinite loop of repeating pivot selection.
  *
  * Space:
@@ -119,13 +119,12 @@ private static int random(int start, int end) {
 
     /**
      * Checks if the given pivot index is a good pivot for the QuickSort algorithm.
-     * A good pivot is defined as an index that helps avoid worst-case behavior in QuickSort.
+     * A good pivot helps avoid worst-case behavior in QuickSort.
+     *
+     * For arrays of length greater than or equal to 10, a good pivot leaves at least 1/10th of the array on each side.
      *
-     * For arrays of length greater than or equal to 10, a good pivot is an index that leaves at least
-     * 1/10th of the array on each side.
-     *  *
      * If n < 10, such a pivot condition would be meaningless, therefore always return true. This would cause
-     * the worst case recurrence relation to be T(n) = T(n-1) + O(n) => O(n^2) for small subarrays, but the overall
+     * the worst case recurrence relation to be T(n) = T(n-1) + O(n) => O(n^2) for small sub-arrays, but the overall
      * asymptotic time complexity of Paranoid QuickSort is still O(nlogn).
      *
      * @param pIdx  The index to be checked for being a good pivot.

src/algorithms/sorting/quickSort/paranoid/QuickSort.java

@@ -1,8 +1,8 @@
 package src.algorithms.sorting.quickSort.threeWayPartitioning;
 
 /**
- * Here, we are implementing QuickSort with three-way partitioning where we sort the array in increasing (or more
- * precisely, non-decreasing) order.
+ * Here, we are implementing Paranoid QuickSort with three-way partitioning where we sort the array in increasing (or
+ * more precisely, non-decreasing) order.
  *
  * Three-way partitioning is used in QuickSort to tackle the scenario where there are many duplicate elements in the
  * array being sorted.
@@ -17,19 +17,14 @@
  *
  * Complexity Analysis:
  * Time:
- * - Worst case (poor choice of pivot): O(n^2)
+ * - Worst case: O(nlogn)
  * - Average case: O(nlogn)
  * - Best case: O(nlogn)
  *
  * By isolating the elements equal to the pivot into their correct positions during the partitioning step, three-way
  * partitioning efficiently handles duplicates, preventing the presence of many duplicates in the array from causing
  * the time complexity of QuickSort to degrade to O(n^2).
  *
- * In the worst case where the pivot selected is consistently the smallest or biggest element in the array, the
- * partitioning of the array around the pivot will be extremely unbalanced, leading to a recurrence relation of:
- * T(n) = T(n-1) + O(n) => O(n^2). However, the likelihood of this happening is extremely low since pivot selection is
- * randomised.
- *
  * Space:
  * - O(1) since sorting is done in-place
  */
@@ -56,9 +51,13 @@ public static void sort(int[] arr) {
     public static void quickSort(int[] arr, int start, int end) {
         if (start < end) {
             int[] newIdx = partition(arr, start, end);
-            if (newIdx != null) {
-                quickSort(arr, start, newIdx[0]);
-                quickSort(arr, newIdx[1], end);
+            if (isGoodPivot(newIdx[0], newIdx[1], start, end)) {
+                if (newIdx != null) {
+                    quickSort(arr, start, newIdx[0]);
+                    quickSort(arr, newIdx[1], end);
+                }
+            } else {
+                quickSort(arr, start, end);
             }
         }
     }
@@ -144,4 +143,43 @@ private static int random(int start, int end) {
         return (int) (Math.random() * (end - start + 1)) + start;
     }
 
+    /**
+     * Checks if the pivot is a good pivot for the QuickSort algorithm.
+     * A good pivot helps avoid worst-case behavior in QuickSort.
+     *
+     * Since we have three-way partitioning, we cannot use 1/10, 9/10 split of the array as our good pivot condition.
+     * Note that our goal here is to ensure the sizes of the sub-arrays QuickSort is to recurse on are roughly the same
+     * to ensure that our partitioning is not too imbalanced. The pivot condition we chose is: the larger sub-array can
+     * be at most 9 times the size of the smaller sub-array.
+     *
+     * If n < 10, such a pivot condition would be meaningless, therefore always return true. This would cause
+     * the worst case recurrence relation to be T(n) = T(n-1) + O(n) => O(n^2) for small sub-arrays, but the overall
+     * asymptotic time complexity of Paranoid QuickSort is still O(nlogn).
+     *
+     * For an all-duplicates array, all pivots will be considered good pivots, therefore return true.
+     *
+     * @param firstPIdx   The ending index of the < portion of the sub-array.
+     * @param secondPIdx  The starting index of the > portion of the sub-array.
+     * @param start       The starting index of the current sub-array.
+     * @param end         The ending index of the current sub-array.
+     * @return            True if the given index is a good pivot, false otherwise.
+     */
+    public static boolean isGoodPivot(int firstPIdx, int secondPIdx, int start, int end) {
+        int n = end - start + 1;
+        if (firstPIdx >= start || secondPIdx <= end) {
+            if (end - secondPIdx + 1 > 0) { // avoid division by zero
+                double ratio = (double) (firstPIdx - start + 1) / (end - secondPIdx + 1);
+                if (n >= 10) {
+                    return ratio >= 1.0 / 9.0 && ratio <= 9;
+                } else {
+                    return true;
+                }
+            } else { // ratio is infinite, imbalanced partition => bad pivot
+                return false;
+            }
+        } else { // all duplicates array
+            return true;
+        }
+    }
+
 }

src/algorithms/sorting/quickSort/threeWayPartitioning/QuickSort.java

@@ -6,7 +6,7 @@
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.*;
 
 public class QuickSortTest {
 
@@ -52,4 +52,5 @@ public void test_selectionSort_shouldReturnSortedArray() {
         assertArrayEquals(fifthResult, fifthArray);
         assertArrayEquals(sixthResult, sixthArray);
     }
+
 }