Standardise README for sorting algors

Author: 4ndrelim

src/algorithms/sorting/bubbleSort/BubbleSort.java

@@ -15,21 +15,6 @@
  *
  * At the kth iteration of the outer loop, we only require (n-k) adjacent comparisons to get the kth largest
  * element to its correct position.
- *
- * Complexity Analysis:
- * Time:
- * - Worst case (reverse sorted array): O(n^2)
- * - Average case: O(n^2)
- * - Best case (sorted array): O(n)
- * In the worst case, during each iteration of the outer loop, the number of adjacent comparisons is upper-bounded
- * by n. Since BubbleSort requires (n-1) iterations of the outer loop to sort the entire array, the total number
- * of comparisons performed can be upper-bounded by (n-1) * n ≈ n^2.
- *
- * This implementation of BubbleSort terminates the outer loop once there are no swaps within one iteration of the
- * outer loop. This improves the best case time complexity to O(n) for an already sorted array.
- *
- * Space:
- * - O(1) since sorting is done in-place
  */
 public class BubbleSort {
     /**

src/algorithms/sorting/bubbleSort/README.md

@@ -1 +1,21 @@
-![bubble sort img](../../../../assets/BubbleSort.jpeg)
+# Bubble Sort
+Bubble sort is one of the more intuitive comparison-based sorting algorithms.
+It makes repeated comparisons between neighbouring elements, 'bubbling' (side-by-side swaps)
+largest (or smallest) element in the unsorted region to the sorted region (often the front or the back).
+
+![bubble sort img](../../../../assets/BubbleSort.jpeg)
+
+## Complexity Analysis
+**Time**:
+  - Worst case (reverse sorted array): O(n^2)
+  - Average case: O(n^2)
+  - Best case (sorted array): O(n)
+
+In the worst case, during each iteration of the outer loop, the number of adjacent comparisons is upper-bounded
+by n. Since BubbleSort requires (n-1) iterations of the outer loop to sort the entire array, the total number
+of comparisons performed can be upper-bounded by (n-1) * n ≈ n^2.
+
+This implementation of BubbleSort terminates the outer loop once there are no swaps within one iteration of the
+outer loop. This improves the best case time complexity to O(n) for an already sorted array.
+
+**Space**: O(1) since sorting is done in-place

src/algorithms/sorting/countingSort/README.md

@@ -1,7 +1,7 @@
 # Counting Sort
 
-Counting sort is a non-comparison based sorting algorithm and isn't bounded by the O(nlogn) lower-bound 
-of most sorting algorithms.
+Counting sort is a non-comparison-based sorting algorithm and isn't bounded by the O(nlogn) lower-bound 
+of most sorting algorithms. <br>
 It first obtains the frequency map of all elements (ie counting the occurrence of every element), then
 computes the prefix sum for the map. This prefix map tells us which position an element should be inserted.
 Ultimately, each group of elements will be placed together, and the groups in succession, in the sorted output.
@@ -17,3 +17,5 @@ COMMON MISCONCEPTION: Counting sort does not require total ordering of elements
 This is incorrect. It requires total ordering of elements to determine their relative positions in the sorted output.
 In fact, in conventional implementation, the total ordering property is reflected by virtue of the structure
 of the frequency map.
+
+Supplementary: Here is a [video](https://www.youtube.com/watch?v=OKd534EWcdk) if you are still having troubles.

src/algorithms/sorting/insertionSort/InsertionSort.java

@@ -3,33 +3,13 @@
 /** Here, we are implementing InsertionSort where we sort the array in increasing (or more precisely, non-decreasing)
  * order.
  *
- * Brief Description:
- * InsertionSort is a simple comparison-based sorting algorithm that builds the final sorted array one element at a
- * time. It works by repeatedly taking an element from the unsorted portion of the array and inserting it into its
- * correct position within the sorted portion. At the kth iteration, we take the element arr[k] and insert
- * it into arr[0, k-1] following sorted order, returning us arr[0, k] in sorted order.
- *
  * Implementation Invariant:
  * The loop invariant is: at the end of kth iteration, the first (k+1) items in the array are in sorted order.
  * At the end of the (n-1)th iteration, all n items in the array will be in sorted order.
- * (Note: the loop invariant here slightly differs from the lecture slides as we are using 0-based indexing.)
- *
- * Complexity Analysis:
- * Time:
- * - Worst case (reverse sorted array): O(n^2)
- * - Average case: O(n^2)
- * - Best case (sorted array): O(n)
- *
- * In the worst case, inserting an element into the sorted array of length m requires us to iterate through the
- * entire array, requiring O(m) time. Since InsertionSort does this insertion (n - 1) times, the time complexity
- * of InsertionSort in the worst case is 1 + 2 + ... + (n-2) + (n-1) = O(n^2).
- *
- * In the best case of an already sorted array, inserting an element into the sorted array of length m requires
- * O(1) time as we insert it directly behind the first position of the pointer in the sorted array. Since InsertionSort
- * does this insertion (n-1) times, the time complexity of InsertionSort in the best case is O(1) * (n-1) = O(n).
  *
- * Space:
- * - O(1) since sorting is done in-place
+ * Note:
+ *      1. the loop invariant here slightly differs from the lecture slides as we are using 0-based indexing
+ *      2. Insertion into the sorted portion is done byb 'bubbling' elements as in bubble sort
  */
 
 public class InsertionSort {

src/algorithms/sorting/insertionSort/README.md

@@ -1,3 +1,36 @@
+# Insertion Sort
+
+Insertion sort is a comparison-based sorting algorithm that builds the final sorted array one element at a
+time. It works by repeatedly taking an element from the unsorted portion of the array and 
+inserting it correctly (portion remains sorted) into the sorted portion. Note that the position is not final 
+since subsequent elements from unsorted portion may displace previously inserted elements. What's important is 
+the sorted region remains sorted. More succinctly: <br>
+At the kth iteration, we take the element arr[k] and insert
+it into arr[0, k-1] following sorted order, returning us arr[0, k] in sorted order.
+
 ![InsertionSort](../../../../assets/InsertionSort.png)
 
+## Complexity Analysis
+**Time**:
+  - Worst case (reverse sorted array): O(n^2)
+  - Average case: O(n^2)
+  - Best case (sorted array): O(n)
+
+In the worst case, inserting an element into the sorted array of length m requires us to iterate through the
+entire array, requiring O(m) time. Since InsertionSort does this insertion (n - 1) times, the time complexity
+of InsertionSort in the worst case is 1 + 2 + ... + (n-2) + (n-1) = O(n^2).
+
+In the best case of an already sorted array, inserting an element into the sorted array of length m requires
+O(1) time as we insert it directly behind the first position of the pointer in the sorted array. Since InsertionSort
+does this insertion (n-1) times, the time complexity of InsertionSort in the best case is O(1) * (n-1) = O(n).
+
+**Space**: O(1) since sorting is done in-place
+
+## Notes
+### Common Misconception
+Its invariant is often confused with selection sort's. In selection sort, an element in the unsorted region will 
+be immediately placed in its correct and final position as it would be in the sorted array. This is not the case
+for insertion sort. However, it is because of this 'looser' invariant that allows for a better best case time complexity
+for insertion sort.
+
 Image Source: https://www.hackerrank.com/challenges/correctness-invariant/problem

src/algorithms/sorting/selectionSort/README.md

@@ -1,3 +1,22 @@
+# Selection Sort
+
+Selection sort is another intuitive comparison-based sorting algorithm. It works similarly to other sorting algorithms 
+like bubble and insertion in the sense that it maintains a sorted and unsorted region. It does so by repeatedly finding
+smallest (or largest) element in the unsorted region, and places the element in the correct and final position as it 
+would be in the sorted array.
+
 ![SelectionSort](../../../../assets/SelectionSort.png)
 
+## Complexity Analysis
+**Time**:
+  - Worst case: O(n^2)
+  - Average case: O(n^2)
+  - Best case: O(n^2)
+
+Regardless of how sorted the input array is, selectionSort will run the minimum element finding algorithm (n-1)
+times. For an input array of length m, finding the minimum element necessarily takes O(m) time. Therefore, the
+time complexity of selectionSort is n + (n-1) + (n-2) + ... + 2 = O(n^2)
+
+**Space**: O(1) since sorting is done in-place
+
 Image Source: https://www.hackerearth.com/practice/algorithms/sorting/selection-sort/tutorial/

src/algorithms/sorting/selectionSort/SelectionSort.java

@@ -3,26 +3,15 @@
 /** Here, we are implementing SelectionSort where we sort the array in increasing (or more precisely, non-decreasing)
  * order.
  *
- * Brief Description and Implementation Invariant:
- * Let the array to be sorted be A of length n. SelectionSort works by finding the minimum element A[j] in A[i...n],
- * then swapping A[i] with A[j], for i in [0, n-1). The loop invariant is: at the end of the kth iteration, the
- * smallest k items are correctly sorted in the first k positions of the array.
+ * Implementation Invariant:
+ * Let the array of length n to be sorted be A.
+ * The loop invariant is:
+ * At the end of the kth iteration, the smallest k items are correctly sorted in the first k positions of the array.
  *
- * At the end of the (n-1)th iteration of the loop, the smallest (n-1) items are correctly sorted in the first (n-1)
+ * So, at the end of the (n-1)th iteration of the loop, the smallest (n-1) items are correctly sorted in the first (n-1)
  * positions of the array, leaving the last item correctly positioned in the last index of the array. Therefore,
  * (n-1) iterations of the loop is sufficient.
  *
- * Complexity Analysis:
- * Time:
- * - Worst case: O(n^2)
- * - Average case: O(n^2)
- * - Best case: O(n^2)
- * Regardless of how sorted the input array is, selectionSort will run the minimum element finding algorithm (n-1)
- * times. For an input array of length m, finding the minimum element necessarily takes O(m) time. Therefore, the
- * time complexity of selectionSort is n + (n-1) + (n-2) + ... + 2 = O(n^2)
- *
- * Space:
- * - O(1) since sorting is done in-place
  */
 
 public class SelectionSort {

src/dataStructures/linkedList/README.md

@@ -18,14 +18,14 @@ linked lists are stored across memory and are connected to each other via pointe
 *Source: BeginnersBook*
 
 ## Analysis
-Time Complexity: Depends on operations, O(n) in general for most operations.
+**Time Complexity**: Depends on operations, O(n) in general for most operations.
 
 Most operations require iterating the linked list. For instance,
 searching for an element in a linked list requires iterating from the head to the tail, incurring O(n)
 time complexity in the worst and average case. The best case would be O(1), for instance, when the head is the desired
 element.
 
-Space Complexity: O(n) where n is the size of the linked list.
+**Space Complexity**: O(n) where n is the size of the linked list.
 
 ## Notes