Changed Hoare's to lecture implementation

Author: kaitinghh

assets/Hoares.jpeg

@@ -1,33 +1,15 @@
 package src.algorithms.sorting.quickSort.hoares;
 
-import java.lang.Math;
-
 /**
  * Here, we are implementing Hoares's QuickSort where we sort the array in increasing (or more precisely,
- * non-decreasing) order.
- *
- * Brief Description:
- * Hoare's QuickSort operates by selecting a pivot element from the input array and rearranging the elements such that
- * all elements in A[start, returnIdx] are <= pivot and all elements in A[returnIdx + 1, end] are >= pivot, where
- * returnIdx is the index returned by the sub-routine partition.
- *
- * After partitioning, the algorithm recursively applies the same process to the left and right sub-arrays, effectively
- * sorting the entire array.
- *
- * The Hoare's partition scheme works by initializing two pointers that start at two ends. The two pointers move toward
- * each other until an inversion is found. This inversion happens when the left pointer is at an element >= pivot, and
- * the right pointer is at an element <= pivot. When an inversion is found, the two values are swapped and the pointers
- * continue moving towards each other.
+ * non-decreasing) order. We will follow lecture implementation here, which differs slightly from the usual
+ * implementation of Hoare's. See more under notes in README.
  *
  * Implementation Invariant:
- * All elements in A[start, returnIdx] are <= pivot and all elements in A[returnIdx + 1, end] are >= pivot.
+ * The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
+ * (We edited the psuedocode a bit to keep the duplicates to the left of the pivot.)
  *
- * Note:
- * - Hoare's partition scheme does not necessarily put the pivot in its correct position. It merely partitions the
- *   array into <= pivot and >= pivot portions.
- * - This is in contrast to Lomuto's partition scheme. Hoare's uses two pointers, while Lomuto's uses one. Hoare's
- *   partition scheme is generally more efficient as it requires less swaps. See more at
- *   https://www.geeksforgeeks.org/hoares-vs-lomuto-partition-scheme-quicksort/.
+ * This implementation picks the element at the index 0 as the pivot.
  */
 
 public class QuickSort {
@@ -51,45 +33,46 @@ public static void sort(int[] arr) {
     public static void quickSort(int[] arr, int start, int end) {
         if (start < end) {
             int pIdx = partition(arr, start, end);
-            quickSort(arr, start, pIdx);
+            quickSort(arr, start, pIdx - 1);
             quickSort(arr, pIdx + 1, end);
         }
     }
 
     /**
      * Partitions the sub-array from index 'start' to index 'end' around a randomly selected pivot element.
-     * After this sub-routine is complete, all elements in A[start, returnIdx] are <= pivot and all elements in
-     * A[returnIdx + 1, end] are >= pivot.
+     * The elements less than or equal to the pivot are placed on the left side, and the elements greater than
+     * the pivot are placed on the right side.
      *
      * Given a sub-array of length m, the time complexity of the partition subroutine is O(m) as we need to iterate
      * through every element in the sub-array once.
      *
      * @param arr   the array containing the sub-array to be partitioned.
      * @param start the starting index (inclusive) of the sub-array to be partitioned.
      * @param end   the ending index (inclusive) of the sub-array to be partitioned.
-     * @return the index at which the array is partitioned at
+     * @return the index of the pivot element in its correct position after partitioning.
      */
     private static int partition(int[] arr, int start, int end) {
-        int pIdx = random(start, end);
-        int pivot = arr[pIdx];
-        int i = start - 1;
-        int j = end + 1;
+        int pivot = arr[start];
+        int low = start + 1;
+        int high = end;
 
-        while (true) {
-            do {
-                i++;
-            } while (arr[i] < pivot);
+        while (low <= high) {
+            while (low <= high && arr[low] <= pivot) {// we use <= as opposed to < to pack duplicates to the left side
+                                                     // of the pivot
+                low++;
+            }
 
-            do {
-                j--;
-            } while (arr[j] > pivot);
+            while (low <= high && arr[high] > pivot) {
+                high--;
+            }
 
-            if (i >= j) {
-                return j;
+            if (low < high) {
+                swap(arr, low, high);
             }
-            swap(arr, i, j);
         }
+        swap(arr, start, low - 1);
 
+        return low - 1;
     }
 
     /**
@@ -105,15 +88,4 @@ private static void swap(int[] arr, int i, int j) {
         arr[j] = temp;
     }
 
-    /**
-     * Generates a random integer within the range [start, end].
-     *
-     * @param start the lower bound of the random integer (inclusive).
-     * @param end   the upper bound of the random integer (inclusive).
-     * @return a random integer within the specified range.
-     */
-    private static int random(int start, int end) {
-        return (int) (Math.random() * (end - start + 1)) + start;
-    }
-
 }

assets/LectureHoares.jpeg

@@ -1 +1,77 @@
-![Hoare's QuickSort with random pivot](../../../../../assets/Hoares.jpeg)
+# Hoare's QuickSort
+
+Our description, analysis and implementation of Hoare's Quicksort here will follow that of lecture implementation.
+Note that the usual Hoare's QuickSort differs slightly from lecture implementation, see more under Notes.
+
+This version of QuickSort assumes the **absence of duplicates** in our array.
+
+QuickSort is a sorting algorithm based on the divide-and-conquer strategy. It works by selecting a pivot element from 
+the array and rearranging the elements such that all elements less than the pivot are on its left, and 
+all elements greater than the pivot are on its right. This effectively partitions the array into two parts. The same 
+process is then applied recursively to the two partitions until the entire array is sorted.
+
+Implementation Invariant:
+
+The pivot is in the correct position, with elements to its left being < it, and elements to its right being > it.
+
+![Lecture Hoare's QuickSort](../../../../../assets/LectureHoares.jpeg)
+Example Credits: Prof Seth/Lecture Slides
+
+## Complexity Analysis
+Complexity Analysis: (this analysis is based on fixed index pivot selection)
+
+Time:
+- 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 
+need to iterate through every element in the sub-array once.
+Therefore, the recurrence relation is: T(n) = 2T(n/2) + O(n) => O(nlogn).
+
+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))
+
+However, using a fixed pivot, such as always choosing the first element as the pivot, can lead to worst-case behavior, 
+especially when the array is already sorted or has a specific pattern. This is because in such cases, the partitioning 
+might create highly unbalanced sub-arrays, causing the algorithm to degrade to O(n^2) time complexity.
+
+## Notes
+
+### Presence of Duplicates
+The above analysis assumes the absence of duplicates in our array. We can change the implementation slightly to keep 
+all elements = pivot to the left of the pivot element. In this case, 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.
+
+### Usual Implementation of Hoare's QuickSort
+The usual implementation of Hoare's partition scheme does not necessarily put the pivot in its correct position. It 
+merely partitions the array into <= pivot and >= pivot portions.
+
+Brief Description:
+
+Hoare's QuickSort operates by selecting a pivot element from the input array and rearranging the elements such
+that all elements in A[start, returnIdx] are <= pivot and all elements in A[returnIdx + 1, end] are >= pivot,
+where returnIdx is the index returned by the sub-routine partition.
+
+After partitioning, the algorithm recursively applies the same process to the left and right sub-arrays, effectively
+sorting the entire array.
+
+The Hoare's partition scheme works by initializing two pointers that start at two ends. The two pointers move toward
+each other until an inversion is found. This inversion happens when the left pointer is at an element >= pivot, and
+the right pointer is at an element <= pivot. When an inversion is found, the two values are swapped and the pointers
+continue moving towards each other.
+
+![Usual Hoare's QuickSort with random pivot](../../../../../assets/UsualHoares.jpeg)
+
+Implementation Invariant:
+
+All elements in A[start, returnIdx] are <= pivot and all elements in A[returnIdx + 1, end] are >= pivot.
+
+## Hoare's vs Lomuto's QuickSort
+Hoare's partition scheme is in contrast to Lomuto's partition scheme. Hoare's uses two pointers, while Lomuto's uses 
+one. Hoare's partition scheme is generally more efficient as it requires less swaps. See more at
+https://www.geeksforgeeks.org/hoares-vs-lomuto-partition-scheme-quicksort/.
+

assets/UsualHoares.jpeg

@@ -13,43 +13,49 @@ public class QuickSortTest {
     @Test
     public void test_selectionSort_shouldReturnSortedArray() {
         int[] firstArray =
-                new int[] {2, 3, 4, 1, 2, 5, 6, 7, 10, 15, 20, 13, 15, 1, 2, 15, 12, 20, 21, 120, 11, 5, 7, 85, 30};
+                new int[] {22, 1, 6, 40, 32, 10, 18, 4, 50};
         int[] firstResult = Arrays.copyOf(firstArray, firstArray.length);
         QuickSort.sort(firstResult);
 
         int[] secondArray
-                = new int[] {9, 1, 2, 8, 7, 3, 4, 6, 5, 5, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+                = new int[] {2, 3, 4, 1, 2, 5, 6, 7, 10, 15, 20, 13, 15, 1, 2, 15, 12, 20, 21, 120, 11, 5, 7, 85, 30};
         int[] secondResult = Arrays.copyOf(secondArray, secondArray.length);
         QuickSort.sort(secondResult);
 
-        int[] thirdArray = new int[] {};
+        int[] thirdArray = new int[] {9, 1, 2, 8, 7, 3, 4, 6, 5, 5, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
         int[] thirdResult = Arrays.copyOf(thirdArray, thirdArray.length);
         QuickSort.sort(thirdResult);
 
-        int[] fourthArray = new int[] {1};
+        int[] fourthArray = new int[] {};
         int[] fourthResult = Arrays.copyOf(fourthArray, fourthArray.length);
         QuickSort.sort(fourthResult);
 
-        int[] fifthArray = new int[] {5,1,1,2,0,0};
+        int[] fifthArray = new int[] {1};
         int[] fifthResult = Arrays.copyOf(fifthArray, fifthArray.length);
         QuickSort.sort(fifthResult);
 
-        int[] sixthArray = new int[] {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+        int[] sixthArray = new int[] {5,1,1,2,0,0};
         int[] sixthResult = Arrays.copyOf(sixthArray, sixthArray.length);
         QuickSort.sort(sixthResult);
 
+        int[] seventhArray = new int[] {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+        int[] seventhResult = Arrays.copyOf(seventhArray, seventhArray.length);
+        QuickSort.sort(seventhResult);
+
         Arrays.sort(firstArray);  // get expected result
         Arrays.sort(secondArray); // get expected result
         Arrays.sort(thirdArray);  // get expected result
         Arrays.sort(fourthArray);  // get expected result
         Arrays.sort(fifthArray);  // get expected result
         Arrays.sort(sixthArray);  // get expected result
+        Arrays.sort(seventhArray);  // get expected result
 
         assertArrayEquals(firstResult, firstArray);
         assertArrayEquals(secondResult, secondArray);
         assertArrayEquals(thirdResult, thirdArray);
         assertArrayEquals(fourthResult, fourthArray);
         assertArrayEquals(fifthResult, fifthArray);
         assertArrayEquals(sixthResult, sixthArray);
+        assertArrayEquals(seventhResult, seventhArray);
     }
 }