refactor: add SRS pseudocode

Author: kam-zhan-yue

src/algorithms/pseudocode/index.js

@@ -3,6 +3,8 @@ export { default as binaryTreeInsertion } from './binaryTreeInsertion';
 export { default as heapSort } from './heapSort';
 export { default as quickSort } from './quickSort';
 export { default as msort_arr_td } from './msort_arr_td';
+export { default as MSDRadixSort } from './MSDRadixSort';
+export { default as straightRadixSort } from './straightRadixSort';
 export { default as msort_lista_td } from './msort_lista_td';
 export { default as transitiveClosure } from './transitiveClosure';
 export { default as prim_old } from './prim_old';

src/algorithms/pseudocode/straightRadixSort.js

@@ -22,7 +22,7 @@ would be good for the counts array.
 Main
 Radixsort(A, n) // Sort array A[1]..A[n] in ascending order. \\B 1
 
-    Find maximum number of "digits" used in the data
+    Find maximum number of "digits" used in the data \\B 2
     \\Expl{  This depends on the radix (base) we use to view the data.
       We could use radix 10 (decimal digits), radix 2
       (binary) or anything else.  Here we use radix 4 for illustration
@@ -31,7 +31,7 @@ Radixsort(A, n) // Sort array A[1]..A[n] in ascending order. \\B 1
       word size rather than scanning all the input data as we do here.
     \\Expl}
 
-    for each digit k up to maximum digit number
+    for each digit k up to maximum digit number \\B 3
     \\Expl{  We scan the digits right to left, from least significant to
       most significant.
     \\Expl}
@@ -46,31 +46,11 @@ Radixsort(A, n) // Sort array A[1]..A[n] in ascending order. \\B 1
 // Done \\B 11
 \\Code}
 
-\\Code{
-MaximumBit
-\\Note{ Skip this
-\\Note}
-maxNumber <- max(A) \\B 2
-maxBit <- 0
-while maxNumber > 0
-\\In{
-    maxNumber <- maxNumber/2
-    maxBit <- maxBit+1
-\\In}
-\\Code}
-
-\\Code{
-RSFor
-\\Note{ Skip this
-\\Note}
-for k <- 0 to maxDigit \\B 3
-\\Code}
-
 \\Code{
 Countingsort
 // Countingsort(A, k, n) \\B 4
-Count number of 1s and 0s in B    \\Ref CountNums
-Array B <- counts or each kth digit value   \\Ref CountNums
+// Count number of 1s and 0s in B
+Array C <- counts of each kth digit value   \\Ref CountNums
 \\Expl{  We count the number of occurrences of each digit value (0-3
   here) in the kth digits of the data.
 \\Expl}
@@ -79,11 +59,11 @@ Cumulatively sum digit value counts    \\Ref CumSum
   plus all smaller digit values. This allows us to determine where the
   last occurrence of each digit value will appear in the sorted array.
 \\Expl}
-Populate temporary array C with sorted numbers    \\Ref Populate
-\\Expl{  We copy the data to temporary array C, using the digit
+Populate temporary array B with sorted numbers    \\Ref Populate
+\\Expl{  We copy the data to temporary array B, using the digit
   value counts to determine where each element is copied to.
 \\Expl}
-Copy C back to A \\B 10
+Copy B back to A \\B 10
 \\Expl{ Array A is now sorted on digit k and all smaller digits
   (because the smaller digits were sorted previously and counting
   sort is stable).
@@ -92,11 +72,11 @@ Copy C back to A \\B 10
 
 \\Code{
 CountNums
-// Put counts of each kth digit value in array B \\B 5
-initialise array B to all zeros
-for num in A
+// Put counts of each kth digit value in array C \\B 5
+initialise array C to all zeros \\B 16
+for num in A \\B 13
 \\In{
-    digit <- kth digit value in num
+    digit <- kth digit value in num \\B 17
     \\Expl{ To extract the kth digit we can use div and mod operations.
       If the radix is a power of two we can use bit-wise operations
       (right shift and bit-wise and) instead.
@@ -106,41 +86,34 @@ for num in A
       highlighted, and the digit value 0-3 (maybe the latter can be done
       by just highlighting B[digit] instead).
     \\Note}
-    B[digit] <- B[digit]+1
+    C[digit] <- C[digit]+1 \\B 12
 \\In}
 \\Code}
 
-\\Code{
-KthBit
-\\Note{ Skip this
-\\Note}
-bit <- (num & (1 << i)) >> i
-\\Code}
-
 \\Code{
 CumSum
 // Cumulatively sum counts \\B 6
 \\Note{ Best remove this comment line and move bookmark
 \\Note}
-for i = 1 to maximum digit value
+for i = 1 to maximum digit value \\B 14
 \\Expl{ We must scan left to right. The count for digit 0 remains
   unchanged.
 \\Expl}
 \\In{
-    B[i] = B[i-1] + B[i]
+    B[i] = B[i-1] + B[i] \\B 15
 \\In}
 \\Code}
 
 \\Code{
 Populate
 // Populate new array C with sorted numbers \\B 7
-for each num in A in reverse order
+for each num in A in reverse order \\B 8
 \\Expl{  We go from right to left so that we preserve the order of numbers
   with the same digit.
   This is CRUCIAL in radix sort as the counting sort MUST be stable.
 \\Expl}
 \\In{
-    digit <- kth digit value in num    \\Ref KthBit
+    digit <- kth digit value in num \\B 19
     \\Expl{ To extract the kth digit value we can use div and mod operations.
       If the radix is a power of two we can use bit-wise operations
       (right shift and bit-wise and) instead.
@@ -150,16 +123,9 @@ for each num in A in reverse order
       highlighted, and the digit value 0-3 (maybe the latter can be done
       by just highlighting B[digit] instead).
     \\Note}
-    B[digit] = B[digit]-1
+    B[digit] = B[digit]-1 \\B 18
     C[B[digit]] = num \\B 9
 \\In}
 \\Code}
 
-\\Code{
-PopFor
-\\Note{ Skip this?
-\\Note}
-for j <- n-1 downto 0 \\B 8
-\\Code}
-
 `);