Fixed comments

Author: kaitinghh

assets/LectureHoares.jpeg

@@ -0,0 +1,22 @@
+# QuickSort
+
+This page will provide a high-level overview of the different types of QuickSort and the significance of each
+enhancement. 
+
+![QuickSort Overview](../../../../assets/QuickSortOverview.jpeg)
+
+We start off with Simple QuickSort, which utilises Hoare's / Lomuto's partitioning with a fixed pivot. But the time 
+complexity of Simple QuickSort degrades to O(n^2) when pivots chosen are continuously bad. This could be because of 
+inputs such as sorted arrays, where picking the first element as the pivot will always lead to an extremely imbalanced 
+partitioning. This could also be because of the presence of duplicates, as we now handle duplicates by putting them to 
+one side of the pivot. 
+
+Therefore, we introduced randomisation in pivot selection to prevent fixed pivot selection from continuously choosing 
+a bad pivot. We also added a good pivot check (Paranoid) to Simple QuickSort to ensure that the pivots we select are 
+"good" and will not cause extremely imbalanced partitions. However, the presence of the good pivot checks will cause 
+infinite recursion when the array contains many duplicates, since any pivot you choose in the array will fail the good
+pivot check. 
+
+So, we introduced 3-way partitioning to handle duplicates by partitioning the array into three sections: elements less 
+than the pivot, elements equal to the pivot, and elements greater than the pivot. Now the good pivot check ignores the 
+size of the segment that comprises elements = to pivot.

assets/Lomutos.jpeg

@@ -7,9 +7,9 @@
  *
  * Implementation Invariant:
  * 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.)
+ * (We edited the pseudocode a bit to keep the duplicates to the left of the pivot.)
  *
- * This implementation picks the element at the index 0 as the pivot.
+ * This implementation picks the first element as the pivot.
  */
 
 public class QuickSort {
@@ -53,18 +53,17 @@ private static void quickSort(int[] arr, int start, int end) {
      */
     private static int partition(int[] arr, int start, int end) {
         int pivot = arr[start];
-        int low = start + 1;
-        int high = end;
+        int low = start;
+        int high = end + 1;
 
-        while (low <= high) {
-            while (low <= high && arr[low] <= pivot) {// we use <= as opposed to < to pack duplicates to the left side
-                                                     // of the pivot
+        while (low < high) {
+            do {
                 low++;
-            }
-
-            while (low <= high && arr[high] > pivot) {
+            } while (low < high && arr[low] <= pivot); // we use <= as opposed to < to pack duplicates to the left side
+                                                       // of the pivot
+            do {
                 high--;
-            }
+            } while (low < high && arr[high] > pivot);
 
             if (low < high) {
                 swap(arr, low, high);

assets/QuickSortOverview.jpeg

@@ -37,6 +37,10 @@ However, using a fixed pivot, such as always choosing the first element as the p
 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.
 
+Space:
+- O(logn) as the partitioning is done in-place so each partitioning takes O(1) space but depth of QuickSort recursion 
+  is logn, therefore logn * O(1) = O(logn)
+
 ## Notes
 
 ### Presence of Duplicates

src/algorithms/sorting/quickSort/README.md

@@ -38,7 +38,8 @@
  * duplicates in the array leads to extremely unbalanced partitioning, leading to a O(n^2) time complexity.
  *
  * Space:
- * - O(1) since sorting is done in-place
+ * - O(logn) as the partitioning is done in-place so each partitioning takes O(1) space but depth of QuickSort
+ *   recursion is logn, therefore logn * O(1) = O(logn)
  */
 
 public class QuickSort {

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

@@ -29,7 +29,8 @@
  * enter an infinite loop of repeating pivot selection.
  *
  * Space:
- * - O(1) since sorting is done in-place
+ * - O(logn) as the partitioning is done in-place so each partitioning takes O(1) space but depth of QuickSort
+ *   recursion is logn, therefore logn * O(1) = O(logn)
  */
 
 public class QuickSort {

src/algorithms/sorting/quickSort/hoares/README.md

@@ -21,12 +21,9 @@
  * - 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).
- *
  * Space:
- * - O(1) since sorting is done in-place
+ * - O(logn) as the partitioning is done in-place so each partitioning takes O(1) space but depth of QuickSort
+ *   recursion is logn, therefore logn * O(1) = O(logn)
  */
 
 public class QuickSort {

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

@@ -42,13 +42,18 @@ public void test_selectionSort_shouldReturnSortedArray() {
         int[] seventhResult = Arrays.copyOf(seventhArray, seventhArray.length);
         QuickSort.sort(seventhResult);
 
+        int[] eighthArray = new int[] {1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+        int[] eighthResult = Arrays.copyOf(eighthArray, eighthArray.length);
+        QuickSort.sort(eighthResult);
+
         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
+        Arrays.sort(eighthArray);  // get expected result
 
         assertArrayEquals(firstResult, firstArray);
         assertArrayEquals(secondResult, secondArray);
@@ -57,5 +62,6 @@ public void test_selectionSort_shouldReturnSortedArray() {
         assertArrayEquals(fifthResult, fifthArray);
         assertArrayEquals(sixthResult, sixthArray);
         assertArrayEquals(seventhResult, seventhArray);
+        assertArrayEquals(eighthResult, eighthArray);
     }
 }