Revamp counting sort description

Author: 4ndrelim

src/main/java/algorithms/sorting/countingSort/CountingSort.java

@@ -2,34 +2,8 @@
 
 /**
  * <p></p> Stable implementation of Counting Sort.
- *
- * <p></p> Brief Description: <br>
- * 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. <br>
- * Ultimately, each group of elements will be placed together, and the groups in succession, in the sorted output.
- *
- * <p></p> Assumption for use: <br>
- * To perform counting sort, the elements must first have total ordering and their rank must be known.
- *
- * <p></p> Implementation Invariant: <br>
- * At the end of the ith iteration, the ith element from the back will be placed in its rightful position.
- *
- * <p></p>
- * COMMON MISCONCEPTION: Counting sort does not require total ordering of elements since it is non-comparison based.
- * 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.
- *
- * <p></p> Complexity Analysis: <br>
- * Time: O(k+n)=O(max(k,n)) where k is the value of the largest element and n is the number of elements. <br>
- * Space: O(k+n)=O(max(k,n)) <br>
- * Counting sort is most efficient if the range of input values do not exceed the number of input values. <br>
- * Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional space to store freq map. <br>
- *
- * <p></p> Note: Implementation deals with integers but the idea is the same and can be generalised to other objects,
- * as long as what was discussed above remains true.
+ * This non-comparison-based sorting algorithm is efficient for sorting integers with a small range.
+ * For detailed explanation and complexity analysis, see README.
  */
 public class CountingSort {
     /**
@@ -40,7 +14,7 @@ public class CountingSort {
     public static int[] sort(int[] arr) {
         int k = 0;
         int n = arr.length;
-        // Find the max. value in arr
+        // Find the max. value in arr. This tells us the size of the freq map array.
         for (int i = 0; i < n; i++) {
             k = Math.max(k, arr[i]);
         }
@@ -53,11 +27,11 @@ public static int[] sort(int[] arr) {
         for (int i = 1; i < k+1; i++) {
             freq[i] += freq[i-1];
         }
-        // Sort the array by placing in output array
+        // Sort the array by placing element in the output array
         int[] sorted = new int[n];
-        for (int i = arr.length-1; i >= 0; i--) { // Notice we start from the back to maintain stable property
+        for (int i = arr.length-1; i >= 0; i--) { // we start from the back to maintain stable property
             int num = arr[i];
-            sorted[freq[num]-1] = num;
+            sorted[freq[num]-1] = num; // freq[num]-1 because 0-indexed
             freq[num]--;
         }
         return sorted;

src/main/java/algorithms/sorting/countingSort/README.md

@@ -1,21 +1,34 @@
 # Counting Sort
 
+## Background
 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
+It first obtains the frequency map of all elements (i.e. 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.
+It is updated after each insertion to reflection the new position to insert the next time the same element is 
+encountered. <br>
+
+### Implementation Invariant
+At the end of the ith iteration, the ith element (of the original array) from the back will be placed in 
+its correct position.
+
+Note: An alternative implementation from the front is easily done with minor modification. 
+The catch is that this implementation is not stable.
+
+### Common Misconception
+_Counting sort does not require total ordering of elements since it is non-comparison based._
+
+This is incorrect. It requires total ordering of elements to determine their relative positions in the sorted output.
+In our implementation, the total ordering property is reflected by virtue of the structure of the frequency map.
 
 ## Complexity Analysis
-Time: O(k+n)=O(max(k,n)) where k is the value of the largest element and n is the number of elements. <br>
-Space: O(k+n)=O(max(k,n)) <br>
+**Time**: O(k+n)=O(max(k,n))  <br>
+**Space**: O(k+n)=O(max(k,n)) <br>
+where k is the value of the largest element and n is the number of elements.
+
 Counting sort is most efficient if the range of input values do not exceed the number of input values. <br>
 Counting sort is NOT AN IN-PLACE algorithm. For one, it requires additional space to store freq map. <br>
 
 ## Notes
-COMMON MISCONCEPTION: Counting sort does not require total ordering of elements since it is non-comparison based.
-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.
+1. Counting sort (stable version) is often used as a sub-routine for radix sort.
+2. Supplementary: Here is a [video](https://www.youtube.com/watch?v=OKd534EWcdk) if you are still having troubles.