Radix sort background etc

Author: lee-naish

src/algorithms/explanations/StraightRadixSortExp.md

@@ -3,55 +3,59 @@
 --- 
 
 ## Introduction
-Straight Radix Sort (SRS) is a **stable** sorting algorithm that processes each digit or each bit of the binary representation 
-of an integer, starting from the least significant digit / bit and working its
-way to the most significant bit / digit. It leverages a non-comparative
-approach, using a **stable** auxiliary sorting algorithm at each stage to reorder the elements by each bit / digit.
-
-## Explanation
+Unlike most sorting algorithms, which are based on *comparison* of whole
+keys, radix sorting is based on examining individual "digits" in the
+keys. For integers (used here) this could be decimal digits (base 10), bits (base 2) or and other
+base. Using bytes (base 256) has efficiency advantages but here we use base 4
+(digits 0-3) for illustration.
+Straight Radix Sort (also known as Least Significant Digit Radix Sort)
+is a *stable* sorting algorithm that processes each digit of the keys
+starting from the least significant digit and working its
+way to the most significant digit. It uses an
+auxiliary sorting algorithm (Counting Sort) at each stage to reorder the
+elements by each digit. Importantly, Counting Sort is *stable*, so when sorting
+on one digit, if two values are equal, the ordering on previously sorted
+digits is retained.
+
+## The algorithm
 ### 1. Initialisation
 The ```Radixsort``` function begins by determining the maximum number of digits, in this case the maximum number of digits
 in the data. This number defines how many iterations the algorithm will go through, 
-starting from the least significant bit (LSB-right most) moving toward the most significant bit (MSB-left most).
-### 2. Iteration through Bits
-* Instead of iterating bit by bit, we have decided to process two consecutive bits at a time and sort based on possible 
-combinations, i.e., (00, 01, 10, 11), starting from the LSB, performing ```Countingsort``` at each step to ensure the elements
-are sorted based on that bit combination.
-* Since bits are processed as a combination of 2, the number of iterations will be reduced. If the maximum number has ```d```
-the algorithm will only need to perform ```d/2``` iterations (rounding up if the number of bits is odd).
-    
+starting from the least significant (right-most) digit moving toward the most
+significant (left-most). Here we use base 4 digits (0-3 or two bits)
+and show values in binary.
+
+### 2. Outer Loop
+For each digit (scanning right to left), *Counting Sort* is performed on that
+digit. This leave the array sorted.
+
 ### 3. Counting Sort
-* Counting occurrences of 00, 01, 10 and 11
-    * For each number in the array, the two-bit value at the current position is extracted.
-    * The algorithm **counts** how many times each two-bit combination occurs.
-  These counts are stored in an auxiliary array ```C```, which has four slots to count the occurrences of each combination.
+* Counting occurrences of each digit (00, 01, 10 and 11 in binary)
+    * For each key in the array, the digit at the current position is extracted.
+    * The algorithm counts how many times each digit occurs.
+    * These counts are stored in an auxiliary array ```Count```, which has a slot for each of the four digit values.
 * Cumulative Sum
-    * After counting the occurrences of the two-bit combinations, the algorithm computes the cumulative sums of these counts
-  in ```C```. This allows the determination of the correct position of each element in the sorted array.
-    * The cumulative sum ensures that elements with the same two-bit value are placed next to each other
-  in the final sorted array while preserving their original order, i.e., the **stability**
-* Populating the Temporary Array ```B```:
-    * ```C[digit]``` determines how many elements have this specific combination, allowing the algorithm to decide where
-  to place the current element.
-    * After placing an element in ```B```, the algorithm decrements the count in ```C[digit]``` by 1, so the next element
-  with the same two-bit combination will be placed in the next available slot.
-
-### 4. Completion
-* Once the sorting based on the current two-bit combination is complete, the temporary array ```B```, which now contains
-the sorted element for the current two-bit combination is copied back to the original array ```A```.
-* The process is repeated for the next two-bit combination until all bits are processed and the array is fully sorted.
+    * After counting the occurrences of the digits, the algorithm computes the cumulative sums of these counts
+  in ```Count```. This allows the determination of the correct position of each element in the sorted array.
+    * Keys with digit value 0 will be put in positions 0 to ```Count[0]-1```; those with value 1 in ```Count[0]``` to ```Count[1]-1```, etc.
+* Copying to temporary Array ```B```:
+    * Array ```A``` is scanned right to left, copying keys to ```B```.
+    * The digit is extracted, ```Count[digit]``` is decremented and then
+      determines which element of ```B``` the key is copied to.
+* The temporary array ```B```, which now contains
+the keys sorted on the current digit, is copied back to the original array ```A```.
 
 ## Complexity
 ### Time Complexity
-* Each iteration requires ```Countingsort```, which requires ```O(n)```, where n is the number of elements.
-* Since our design processes two bits at a time, the number of iterations is halved, hence, if the maximum number in the
-array has ```d``` bits, the number of iterations is ```O(d/2)```
-* As a result, the overall time complexity is: ```O(n * d/2)``` -> ```O(n * d)```
+* Each iteration uses ```Countingsort```, which requires ```O(n)```, where n is the number of elements.
+* If we *assume the number of digits is limited* the overall time complexity is: ```O(n)```
+* Note that the best comparison-based sorting algorithms have ```O(n log n)```
+  complexity, but the number of digits is typically related to ```log n```
+  so radix sorts are not necessarily better.
 
 ### Space Complexity
-* Original Array ```A```: ```O(n)```
-* Counting Array ```C```: ```O(1)```, constant space of 4 in this case.
-* Temporary Array ```B```: ```O(n)```,
-* As a result, the overall time complexity is: ```O(n)```
+* Due to the temporary array ```B``` we need ```O(n)``` extra space.
+* The ```Count``` array is considered constant space (though potentially a
+  very large radix could be used).
 
 

src/algorithms/extra-info/MSDRadixSortInfo.md

@@ -0,0 +1,23 @@
+<style>
+a:link {
+    color: #1e28f0;
+}
+a:visited{
+    color: #3c1478;
+}
+a:hover{
+    color: #1e288c;
+}
+</style>
+
+## Extra Info
+
+-----
+
+Geeks for Geeks Link: [**(MSD) Radix Sort**][G4GLink] (also known as Radix Exchange
+Sort)
+
+
+[G4GLink]: https://www.geeksforgeeks.org/msd-most-significant-digit-radix-sort/
+
+

src/algorithms/extra-info/StraightRadixSortInfo.md

@@ -0,0 +1,23 @@
+<style>
+a:link {
+    color: #1e28f0;
+}
+a:visited{
+    color: #3c1478;
+}
+a:hover{
+    color: #1e288c;
+}
+</style>
+
+## Extra Info
+
+-----
+
+Geeks for Geeks Links: [**(Straight/LSD) Radix Sort**][G4GLink] and
+[**Counting Sort**][G4GLink2] (also known as Distribution counting)
+
+
+[G4GLink]: https://www.geeksforgeeks.org/radix-sort/
+[G4GLink2]: https://www.geeksforgeeks.org/counting-sort/
+