docs: refactor quicksort readmes

Author: kaitinghh

src/main/java/algorithms/sorting/mergeSort/recursive/README.md

@@ -1,6 +1,6 @@
 # Merge Sort
 
-### Brief Description:
+### Background
 MergeSort is a divide-and-conquer sorting algorithm. The recursive implementation takes a top-down approach by
 recursively dividing the array into two halves, sorting each half separately, and then merging the sorted halves
 to produce the final sorted output.
@@ -9,11 +9,11 @@ to produce the final sorted output.
 
 Image Source: https://www.101computing.net/merge-sort-algorithm/
 
-### Implementation Invariant (for the merging subroutine):
+### Implementation Invariant (for the merging subroutine)
 The sub-array temp[start, (k-1)] consists of the (𝑘−start) smallest elements of arr[start, mid] and
 arr[mid + 1, end], in sorted order.
 
-### Complexity Analysis:
+### Complexity Analysis
 Time:
 - Worst case: O(nlogn)
 - Average case: O(nlogn)

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

@@ -78,7 +78,7 @@ 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 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

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

@@ -3,40 +3,6 @@
 /**
  * Here, we are implementing Lomuto's QuickSort where we sort the array in increasing (or more precisely,
  * non-decreasing) order.
- * <p>
- * Basic Description:
- * 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 an extreme element getting chosen as the pivot is decreased, so we
- * reduce the probability of encountering the worst-case scenario of imbalanced partitioning.
- * <p>
- * Implementation Invariant:
- * The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
- * <p>
- * We are implementing Lomuto's partition scheme here. This is opposed to Hoare's partition scheme, see more at
- * https://www.geeksforgeeks.org/hoares-vs-lomuto-partition-scheme-quicksort/.
- * <p>
- * Complexity Analysis:
- * Time:
- * - Expected worst case (poor choice of pivot): O(n^2)
- * - Expected average case: O(nlogn)
- * - Expected best case (balanced pivot): O(nlogn)
- * <p>
- * 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).
- * <p>
- * 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))
- * <p>
- * 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.
- * <p>
- * Space:
- * - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
  */
 
 public class QuickSort {

src/main/java/algorithms/sorting/quickSort/lomuto/README.md

@@ -1,3 +1,12 @@
+# Lomuto's QuickSort
+
+## Background
+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 an extreme element getting chosen as the pivot is decreased, so we
+reduce the probability of encountering the worst-case scenario of imbalanced partitioning.
+
 This is how QuickSort works if we always pick the first element as the pivot with Lomuto's partitioning.
 
 ![QuickSort with first element as pivot](../../../../../../../docs/assets/images/QuickSortFirstPivot.png)
@@ -9,3 +18,34 @@ need to do is to swap the random pivot to the first element in the array, then p
 then swap the pivot back to its correct position. Below is an illustration:
 
 ![Lomuto's QuickSort with random pivot](../../../../../../../docs/assets/images/Lomutos.jpeg)
+
+## Implementation Invariant
+The pivot is in the correct position, with elements to its left being <= it, and elements to its right being > it.
+
+## Complexity Analysis:
+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, 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.
+
+Space:
+- O(1) excluding memory allocated to the call stack, since partitioning is done in-place
+
+## Notes
+### Lomuto's vs Hoare's QuickSort
+
+Lomuto's partition scheme is in contrast to Hoare'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/.

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

@@ -3,31 +3,9 @@
 /**
  * Here, we are implementing Paranoid QuickSort where we sort the array in increasing (or more precisely,
  * non-decreasing) order.
- * <p>
- * This is basically Lomuto's QuickSort, with an additional check to guarantee a good pivot.
- * <p>
- * Complexity Analysis:
- * 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)
- * <p>
- * 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).
- * <p>
- * 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.
- * <p>
- * Therefore, the expected time-complexity is: T(n) = T(n/10) + T(9n/10) + 1.25n => O(nlogn).
- * <p>
- * 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.
- * <p>
- * Space:
- * - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
+ *
+ * We are implementing this with the Lomuto's partitioning scheme, with an additional check to guarantee a good pivot.
+ * You could also implement this with the Hoare's partitioning scheme instead.
  */
 
 public class QuickSort {

src/main/java/algorithms/sorting/quickSort/paranoid/README.md

@@ -1 +1,29 @@
-![ParanoidQuickSort](../../../../../../../docs/assets/images/ParanoidQuickSort.jpeg)
+# Paranoid QuickSort
+
+### Background 
+Paranoid Quicksort is the naive quicksort with an additional check to guarantee a good pivot.
+
+![ParanoidQuickSort](../../../../../../../docs/assets/images/ParanoidQuickSort.jpeg)
+
+### Complexity Analysis:
+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 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 expected time-complexity is: T(n) = T(n/10) + T(9n/10) + 1.25n => O(nlogn).
+
+- 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:
+- O(1) excluding memory allocated to the call stack, since partitioning is done in-place

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

@@ -3,26 +3,6 @@
 /**
  * Here, we are implementing Paranoid QuickSort with three-way partitioning where we sort the array in increasing (or
  * more precisely, non-decreasing) order.
- * <p>
- * Three-way partitioning is used in QuickSort to tackle the scenario where there are many duplicate elements in the
- * array being sorted.
- * <p>
- * The idea behind three-way partitioning is to divide the array into three sections: elements less than the pivot,
- * elements equal to the pivot, and elements greater than the pivot. By doing so, we can avoid unnecessary comparisons
- * and swaps with duplicate elements, making the sorting process more efficient.
- * <p>
- * Implementation Invariant:
- * The pivot and any element numerically equal to the pivot will be in the correct positions in the array. Elements
- * to their left are < them and elements to their right are > than them.
- * <p>
- * Complexity Analysis:
- * Time:
- * - Worst case: O(nlogn)
- * - Average case: O(nlogn)
- * - Best case: O(nlogn)
- * <p>
- * Space:
- * - O(1) excluding memory allocated to the call stack, since partitioning is done in-place
  */
 
 public class QuickSort {

src/main/java/algorithms/sorting/quickSort/threeWayPartitioning/README.md

@@ -1 +1,25 @@
-![ThreeWayPartitioning](../../../../../../../docs/assets/images/ThreeWayPartitioning.jpeg)
+# Three-Way Partitioning
+
+### Background
+Three-way partitioning is used in QuickSort to tackle the scenario where there are many duplicate elements in the
+array being sorted.
+
+The idea behind three-way partitioning is to divide the array into three sections: elements less than the pivot,
+elements equal to the pivot, and elements greater than the pivot. By doing so, we can avoid unnecessary comparisons
+and swaps with duplicate elements, making the sorting process more efficient.
+
+![ThreeWayPartitioning](../../../../../../../docs/assets/images/ThreeWayPartitioning.jpeg)
+
+### Implementation Invariant:
+The pivot and any element numerically equal to the pivot will be in the correct positions in the array. Elements
+to their left are < them and elements to their right are > than them.
+
+### Complexity Analysis:
+Time:
+- Worst case: O(nlogn)
+- Average case: O(nlogn)
+- Best case: O(nlogn)
+
+Space:
+- O(1) excluding memory allocated to the call stack, since partitioning is done in-place
+