Merge pull request #73 from kaitinghh/branch-sortsreadme

Branch Sorts READMEs

Author: 4ndrelim

src/main/java/algorithms/sorting/mergeSort/iterative/MergeSort.java

@@ -3,39 +3,6 @@
 /**
  * Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
  * order iteratively.
- * <p>
- * Brief Description:
- * The iterative implementation of MergeSort takes a bottom-up approach, where the sorting process starts by merging
- * intervals of size 1. Intervals of size 1 are trivially in sorted order. The algorithm then proceeds to merge
- * adjacent sorted intervals, doubling the interval size with each merge step, until the entire array is fully sorted.
- * <p>
- * Implementation Invariant:
- * At each iteration of the merging process, the main array is divided into sub-arrays of a certain interval
- * size (interval). Each of these sub-arrays is sorted within itself. The last sub-array may not be of size
- * interval, but it is still sorted since its size is necessarily less than interval.
- * <p>
- * Complexity Analysis:
- * Time:
- * - Worst case: O(nlogn)
- * - Average case: O(nlogn)
- * - Best case: O(nlogn)
- * <p>
- * Given two sorted arrays of size p and q, we need O(p + q) time to merge the two arrays into one sorted array, since
- * we have to iterate through every element in both arrays once.
- * <p>
- * At the 1st level of the merge process, our merging subroutine involves n sub-arrays of size 1, taking O(n) time.
- * At the 2nd level of the merge process, our merging subroutine involves (n/2) sub-arrays of size 2, taking O(n) time.
- * At the kth level of the merge process, our merging subroutine involves (n/(2^(k-1))) sub-arrays of size (2^(k-1)),
- * taking O(n) time.
- * <p>
- * Since interval doubles at every iteration of the merge process, there are logn such levels. Every level takes
- * O(n) time, hence overall time complexity is n * logn = O(nlogn)
- * <p>
- * Regardless of how sorted the input array is, MergeSort carries out the partitioning and merging process, so the
- * time complexity of MergeSort is O(nlogn) for all cases.
- * <p>
- * Space:
- * - O(n) since we require a temporary array to temporarily store the merged elements in sorted order
  */
 
 public class MergeSort {

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

@@ -1,3 +1,38 @@
+# Merge Sort
+
+### Background
+The iterative implementation of MergeSort takes a bottom-up approach, where the sorting process starts by merging
+intervals of size 1. Intervals of size 1 are trivially in sorted order. The algorithm then proceeds to merge
+adjacent sorted intervals, doubling the interval size with each merge step, until the entire array is fully sorted.
+
 ![MergeSort Iterative](../../../../../../../docs/assets/images/MergeSortIterative.jpg)
 
-Image Source: https://www.chelponline.com/iterative-merge-sort-12243
+Image Source: https://www.chelponline.com/iterative-merge-sort-12243
+
+### Implementation Invariant
+At each iteration of the merging process, the main array is divided into sub-arrays of a certain interval
+size (interval). Each of these sub-arrays is sorted within itself. The last sub-array may not be of size
+interval, but it is still sorted since its size is necessarily less than interval.
+
+### Complexity Analysis
+Time:
+- Worst case: O(nlogn)
+- Average case: O(nlogn)
+- Best case: O(nlogn)
+
+Given two sorted arrays of size p and q, we need O(p + q) time to merge the two arrays into one sorted array, since
+we have to iterate through every element in both arrays once.
+
+- At the 1st level of the merge process, our merging subroutine involves n sub-arrays of size 1, taking O(n) time.
+- At the 2nd level of the merge process, our merging subroutine involves (n/2) sub-arrays of size 2, taking O(n) time.
+- At the kth level of the merge process, our merging subroutine involves (n/(2^(k-1))) sub-arrays of size (2^(k-1)),
+taking O(n) time.
+
+Since interval doubles at every iteration of the merge process, there are logn such levels. Every level takes
+O(n) time, hence overall time complexity is n * logn = O(nlogn)
+
+Regardless of how sorted the input array is, MergeSort carries out the partitioning and merging process, so the
+time complexity of MergeSort is O(nlogn) for all cases.
+
+Space:
+- O(n) since we require a temporary array to temporarily store the merged elements in sorted order

src/main/java/algorithms/sorting/mergeSort/legacy/iterative/MergeSort.java

@@ -3,31 +3,6 @@
 /**
  * Here, we are implementing MergeSort where we sort the array in increasing (or more precisely, non-decreasing)
  * order recursively.
- * <p>
- * Brief Description:
- * 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.
- * <p>
- * 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.
- * <p>
- * Complexity Analysis:
- * Time:
- * - Worst case: O(nlogn)
- * - Average case: O(nlogn)
- * - Best case: O(nlogn)
- * Merging two sorted sub-arrays of size (n/2) requires O(n) time as we need to iterate through every element in both
- * sub-arrays in order to merge the two sorted sub-arrays into one sorted array.
- * <p>
- * Recursion expression: T(n) = 2T(n/2) + O(n) => O(nlogn)
- * <p>
- * Regardless of how sorted the input array is, MergeSort carries out the same divide-and-conquer strategy, so the
- * time complexity of MergeSort is O(nlogn) for all cases.
- * <p>
- * Space:
- * - O(n) since we require a temporary array to temporarily store the merged elements in sorted order
  */
 
 public class MergeSort {

src/main/java/algorithms/sorting/mergeSort/legacy/recursive/MergeSort.java

@@ -1,3 +1,30 @@
+# Merge Sort
+
+### 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.
+
 ![MergeSort Recursive](../../../../../../../docs/assets/images/MergeSortRecursive.png)
 
-Image Source: https://www.101computing.net/merge-sort-algorithm/
+Image Source: https://www.101computing.net/merge-sort-algorithm/
+
+### 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
+Time:
+- Worst case: O(nlogn)
+- Average case: O(nlogn)
+- Best case: O(nlogn)
+Merging two sorted sub-arrays of size (n/2) requires O(n) time as we need to iterate through every element in both
+sub-arrays in order to merge the two sorted sub-arrays into one sorted array.
+
+Recursion expression: T(n) = 2T(n/2) + O(n) => O(nlogn)
+
+Regardless of how sorted the input array is, MergeSort carries out the same divide-and-conquer strategy, so the
+time complexity of MergeSort is O(nlogn) for all cases.
+
+Space:
+- O(n) since we require a temporary array to temporarily store the merged elements in sorted order

src/main/java/algorithms/sorting/mergeSort/recursive/MergeSort.java

@@ -5,21 +5,23 @@ Note that the usual Hoare's QuickSort differs slightly from lecture implementati
 
 This version of QuickSort assumes the **absence of duplicates** in our array.
 
+## Background
+
 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:
+## 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](../../../../../../../docs/assets/images/LectureHoares.jpeg)
 Example Credits: Prof Seth/Lecture Slides
 
 ## Complexity Analysis
-
-Complexity Analysis: (this analysis is based on fixed index pivot selection)
+* This analysis is based on fixed index pivot selection.
+* The complexity analysis for Hoare's quicksort is the same as that of Lomuto's quicksort. 
 
 Time:
 
@@ -78,7 +80,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/mergeSort/recursive/README.md

@@ -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 {