Partition in REX++

Author: lee-naish

src/algorithms/controllers/MSDRadixSort.js

@@ -54,6 +54,7 @@ const MSD_BOOKMARKS = {
   partition_right: 305,
   swap_condition: 309,
   swap: 310,
+  inc_dec: 'inc_dec',
   pre_sort_left: 400,
   sort_left: 401,
   pre_sort_right: 500,
@@ -159,7 +160,13 @@ export default {
       // where mid is undefined until after partition
       const finished_stack_frames = [];
       const real_stack = [];
-      let leftCheck = false
+      // refreshStack does lots of work with highlighting etc but is
+      // called from other functions which are called from other
+      // function and somewhere along the line one of the functions is
+      // chunker.add. Often the arguments are not given explicitly -
+      // it's a mess. We assign the current bookmark to whereAreWe for
+      // now, to be used in refreshStack.  Maybe worth a re-write XXX.
+      let whereAreWe;
 
       // ----------------------------------------------------------------------------------------------------------------------------
       // Define helper functions
@@ -169,14 +176,12 @@ export default {
       // This function is the only way information is cached and incremented properly in the while loop
       const partitionChunker = (bookmark, i, j, prev_i, prev_j, left, right, depth, arr, mask) => {
         assert(bookmark !== undefined); // helps catch bugs early, and trace them in stack
-        const args_array = [real_stack, finished_stack_frames, i, j, prev_i, prev_j, left, right, depth, leftCheck, maxIndex, arr, mask]
+        const args_array = [real_stack, finished_stack_frames, i, j, prev_i, prev_j, left, right, depth, whereAreWe, maxIndex, arr, mask]
         chunker.add(bookmark, refreshStack, args_array, depth)
       }
 
-      // we use a global flag in case we scan through the whole partition 
-      // and stop at the end without finding the mask bit we are looking
-      // for
-      const refreshStack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, prev_i, prev_j, left, right, cur_depth, checkingLeft, maxIndex, arr, mask) => {
+      // see comment above on whereAreWe
+      const refreshStack = (vis, cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, prev_i, prev_j, left, right, cur_depth, whereAreWe, maxIndex, arr, mask) => {
         // If we fall off the start/end of the array we just use the
         // first/last element and give the actual value of j/i
         let cur_i_too_high;
@@ -198,17 +203,13 @@ export default {
         assert(vis.array);
         assert(cur_real_stack && cur_finished_stack_frames);
 
-        vis.array.setStackDepth(cur_real_stack.length);
-        vis.array.setStack(
-          deriveStack(cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_depth)
-        );
+        // XXX This was getting very messy - colors depends a
+        // lot on where we are and we had a bunch of tricky testing of
+        // various vars to determine that.  Now we use whereAreWe to
+        // simplify some things at least.
 
-        // XXX This is getting very messy - (un)highlighting depends a
-        // lot on where we are and we have a bunch of tricky testing of
-        // various vars to determine that.  Could pass in bookmark to
-        // simplify some things at least??
         // Show the binary representation for the current index
-        // plus (un)highlight appropriate element(s)
+        // plus color appropriate element(s)
         updateMask(vis, mask) // only needed for start of recursive function
         if (maxIndex !== undefined) { // top level call to recursive fn
           unhighlight(vis, maxIndex)
@@ -222,8 +223,18 @@ export default {
             vis.array.selectColor(prev_j, partLColor)
           for (let k = cur_i; k <= right; k++)
             vis.array.deselect(k);
-        } else if (checkingLeft) {
+        } else if (whereAreWe === MSD_BOOKMARKS.partition_left) {
           // note i can fall off RHS of array...
+          if (cur_i !== undefined && cur_i <= right ) {
+            updateBinary(vis, arr[cur_i]);
+            if ((arr[cur_i] >> mask & 1) === 1)
+              vis.array.selectColor(cur_i, partRColor)
+            else {
+              vis.array.selectColor(cur_i, partLColor);
+              cur_i++; // show incremented i  XXX fix i_too_high
+            }
+          }
+/*
           if (prev_i !== undefined && prev_i !== cur_j) {
             let real_i = cur_i;
             if (cur_i === undefined)
@@ -235,7 +246,8 @@ export default {
           }
           if (arr && cur_i !== undefined)
             updateBinary(vis, arr[cur_i])
-        } else {
+*/
+        } else if (whereAreWe === MSD_BOOKMARKS.partition_right) {
           // note j can fall off LHS of array...
           if (prev_j !== undefined && prev_j !== cur_i)
             for (let k = prev_j; k >= cur_j && k >= cur_i; k--)
@@ -246,6 +258,11 @@ export default {
             updateBinary(vis, arr[cur_j])
           }
         }
+
+        vis.array.setStackDepth(cur_real_stack.length);
+        vis.array.setStack(
+          deriveStack(cur_real_stack, cur_finished_stack_frames, cur_i, cur_j, cur_depth)
+        );
         if (left < A.length) // shouldn't happen with initial mask choice
           assignVariable(vis, VIS_VARIABLE_STRINGS.left, left);
         if (right >= 0) {
@@ -382,16 +399,18 @@ arr],
           prev_i = i; // save prev value for unhighlighting
           prev_j = j;
           // Build the left group until it reaches the mask (find the big element)
-          leftCheck = true
+          // leftCheck = true
+          whereAreWe = MSD_BOOKMARKS.partition_left;
           while (i <= j && (arr[i] >> mask & 1) === 0) {
-            // partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
+            partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
             i++
           }
           partitionChunkerWrapper(MSD_BOOKMARKS.partition_left)
           // Build the right group until it fails the mask (find the small element)
-          leftCheck = false
+          // leftCheck = false
+          whereAreWe = MSD_BOOKMARKS.partition_right;
           while (j > i && (arr[j] >> mask & 1) === 1) {
-            // partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
+            partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
             j--
           }
           partitionChunkerWrapper(MSD_BOOKMARKS.partition_right)
@@ -400,6 +419,9 @@ arr],
           if (i < j) {
             partitionChunkerWrapper(MSD_BOOKMARKS.swap_condition)
             swapAction(MSD_BOOKMARKS.swap, i, j)
+            i++;
+            j--;
+            partitionChunkerWrapper(MSD_BOOKMARKS.inc_dec)
           } else {
             // about to return i from partition.  We update the "mid" of
             // the partition on the stack here so it is displayed at the

src/algorithms/explanations/MSDRadixSortExp.md

@@ -41,15 +41,16 @@ mask bit of each key:
     * Increment ```i``` until an element with a 1 as the mask bit is reached
     * Decrement ```j``` until an element with a 0 as the mask bit is reached
 
-* If the two guards have not crossed, perform a swap to ensure that 0s are placed on the left and 1s on the right.
+* If the two indices have not met/crossed, perform a swap to ensure that 0s are placed on the left and 1s on the right.
 
 ## Complexity
 ### Time Complexity
-* Partitioning takes```O(n)```, where ```n``` is the number elements in the
+* Partitioning takes ```O(n)```, where ```n``` is the number elements in the
 array.
-* If we *assume the number of bits is limited* the overall time complexity is: ```O(n)``` 
+* If we *assume the maximum number of digits is fixed* 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 bits is typically related to ```log n```
+  (otherwise there must be many duplicate keys)
   so radix sorts are not necessarily better.
 
 ### Space Complexity

src/algorithms/explanations/StraightRadixSortExp.md

@@ -5,7 +5,7 @@
 ## Introduction
 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
+keys. For integers (used here) this could be decimal digits (base 10), bits (base 2) or any 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)
@@ -23,13 +23,17 @@ The ```Radixsort``` function begins by determining the maximum number of digits,
 in the data. This number defines how many iterations the algorithm will go through, 
 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.
+and show values in decimal, base 4 (the most helpful in understanding
+the algorithm) and 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 sort has four parts:
+
 * 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.
@@ -47,10 +51,11 @@ the keys sorted on the current digit, is copied back to the original array ```A`
 
 ## Complexity
 ### Time Complexity
-* 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)```
+* Each iteration uses ```Countingsort```, which takes ```O(n)``` time, where n is the number of elements.
+* If we *assume the maximum number of digits is fixed* 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```
+  (otherwise there must be many duplicate keys)
   so radix sorts are not necessarily better.
 
 ### Space Complexity

src/algorithms/pseudocode/MSDRadixSort.js

@@ -76,7 +76,7 @@ i,j <- left,right \\B 301
 stopping at "small" elements (with "0" as the mask bit).
 \\Expl}
 while i < j \\B 303
-\\Expl{ When the indices cross, all the large elements at the left of
+\\Expl{ When the indices meet/cross, all the large elements at the left of
         the array segment have been swapped with small elements from the
         right of the array segment. The coding here can be simplified
         if we use "break" or similar to exit from this loop.
@@ -95,13 +95,14 @@ while i < j \\B 303
         Note we do the tests before decrementing j.
     \\Expl}
     if i < j \\B 309
-    \\Expl{ If the indices cross, we exit the loop.
+    \\Expl{ If the indices meet/cross, we exit the loop.
     \\Expl}
     \\In{
         swap(A[i], A[j]) \\B 310
         \\Expl{ Swap the larger element (A[i]) with the smaller
                 element (A[j]).
         \\Expl}
+        Increment i and decrement j \\B inc_dec
     \\In}
 \\In}
 \\Code}