Heapsort fixes

Author: lee-naish

src/algorithms/controllers/heapSort.js

@@ -44,6 +44,11 @@ function isDownHeapkExpanded() {
   return areExpanded(['BuildHeap', 'DownHeapk']);
 }
 
+// i, j (in sort) displayed only if second DownHeap is expanded
+function isDownHeap1Expanded() {
+  return areExpanded(['SortHeap', 'DownHeap1']);
+}
+
 export default {
   initVisualisers() {
     return {
@@ -133,7 +138,6 @@ export default {
 
       chunker.add(4, (vis, index1, index2) => {
         vis.array.assignVariable('k', index1);
-        // if (tmp != null) {  // XXX looks dodgy using tmp here?
         if (index2 != null) {
           unhighlight(vis, index2);
           vis.array.removeVariable('j');
@@ -174,40 +178,44 @@ export default {
         // parent is greater than largest child, so it is already a valid heap
         if (A[i] >= A[j]) {
           heap = true;
-          chunker.add(15, (vis, index, lastH) => {
+          chunker.add(15, (vis, index, lastH, cur_k) => {
             unhighlight(vis, index, false);
             // possible last chunk in BuildHeap/DownHeapk
             // remove i, j if !isDownHeapkExpanded
             if (!isDownHeapkExpanded()) {
               vis.array.removeVariable('i');
               vis.array.removeVariable('j');
             }
-            // remove k+highlighting if !isBuildHeapExpanded
-            if (!isBuildHeapExpanded()) {
+            // remove k+highlighting if !isBuildHeapExpanded & last
+            // chunk of BuildHeap
+            if (!isBuildHeapExpanded() && cur_k === 0) {
               vis.array.removeVariable('k');
-              unhighlight(vis, lastH);
+              if (lastH !== index)
+                unhighlight(vis, lastH);
             }
-          }, [j, lastiHighlight]);
+          }, [j, lastiHighlight, k]);
         } else {
           swap = A[i];
           A[i] = A[j];
           A[j] = swap;
           swapAction(17, i, j);
           lastiHighlight = j;
-          chunker.add(18, (vis, p, c, lastH) => {
+          chunker.add(18, (vis, p, c, lastH, cur_k) => {
             unhighlight(vis, p, false);
             vis.array.assignVariable('i', c);
             // remove i, j if !isDownHeapkExpanded
             if (!isDownHeapkExpanded()) {
               vis.array.removeVariable('i');
               vis.array.removeVariable('j');
             }
-            // remove k+highlighting if !isDownHeapkExpanded
-            if (!isBuildHeapExpanded()) {
+            // remove k+highlighting if !isDownHeapkExpanded & last
+            // chunk of BuildHeap
+            if (!isBuildHeapExpanded() && cur_k === 0) {
               vis.array.removeVariable('k');
-              unhighlight(vis, lastH);
+              if (lastH !== p)
+                unhighlight(vis, lastH);
             }
-          }, [i, j, lastiHighlight]);
+          }, [i, j, lastiHighlight, k]);
           i = j;
         }
       }
@@ -220,7 +228,7 @@ export default {
         // clear variables & show 'n'
         vis.array.clearVariables();
         vis.array.assignVariable('n', nVal - 1);
-        unhighlight(vis, index); // XXX skip for first loop iteration?
+        unhighlight(vis, index);
       }, [n, i]);
 
       let j;
@@ -286,6 +294,11 @@ export default {
           chunker.add(36, (vis, p, c) => {
             unhighlight(vis, p, false);
             vis.array.assignVariable('i', c);
+            // remove i, j if !isDownHeap1Expanded
+            if (!isDownHeap1Expanded()) {
+              vis.array.removeVariable('i');
+              vis.array.removeVariable('j');
+            }
           }, [i, j]);
           i = j;
         }
@@ -294,10 +307,10 @@ export default {
     chunker.add(37, (vis) => {
       // Put in done state
       vis.array.clearVariables();
-      vis.array.deselect(0);
+      // vis.array.deselect(0);
+      unhighlight(vis, 0, true);
       vis.array.sorted(0);
       vis.heap.sorted(1);
-      unhighlight(vis, 0, true);
     });
     // for test
     return A;

src/algorithms/explanations/HSExp.md

@@ -3,8 +3,8 @@
 ---
 
 Heapsort is a general purpose in-place sorting algorithm that has
-*<verbatim>O(n log n)</verbatim>* behavior in the worst case. It achieves
-this by first rearranging the array so it is a *heap* (which has some
+*<verbatim>O(n log n)</verbatim>* behavior in the worst case. It
+proceeds by first rearranging the array so it is a *heap* (which has some
 ordering maintained; see below) then converting the heap into a sorted
 array.
 
@@ -17,12 +17,13 @@ the root in *<verbatim>A[1]</verbatim>* and the children of
 it's children (this is called the *heap condition*), thus the root is
 the maximum (heap sort uses a "max" heap; there are also "min" heaps
 where the ordering is reversed).  Note that there are no pointers etc -
-we can view the array as a tree so as to understand the ordering.
+we can view the array as a tree so as to understand the ordering. In
+AIA, both views of this single data structure are displayed.
 
 ## Building a heap "bottom up"
 
 The best way to build a heap from an unordered array is to first note that
-all the leaf nodes in the tree view are already heaps (they have no cildren
+all the leaf nodes in the tree view are already heaps (they have no children
 so the heap condition is satisfied), and work up the tree (backwards
 through the array) to the root. Each step combines two existing heaps
 plus their parent node to form a new heap (some rearrangement may be
@@ -32,23 +33,23 @@ needed; this is done by the *DownHeap* operation).
 
 Sorting proceeds by repeating the following steps:
 
-- swap the largest item (the root) with the last item in the array
+- swap the largest item (the root) with the last item in the heap
 - remove this largest item from further consideration (it is no longer
   considered part of the heap)
-- reform the remaining data items into heap order by performing
-  *DownHeap* on the new root (note the two children of the root remain
-  heaps)
+- rearrange the remaining data items into heap order by performing
+  *DownHeap* on the new root (note the two children of the root are
+  heaps before this step)
 
 ## The DownHeap operation
 
 *DownHeap* traverses down the tree, swapping the data in the node with
 the maximum child of the node.  It stops as soon as the data in the node
 is greater than or equal to the maximum child (or the node is a leaf).
-The time complexity is *O(log n)*
 
 ## Complexity
 
-The worst case and nearly all other cases have time complexity *O(n log n)*.
+The time complexity of *DownHeap* is *O(log n)*. Overall for Heapsort
+the worst case and nearly all other cases have time complexity *O(n log n)*.
 Space complexity is O(1).
 
 

src/algorithms/extra-info/HSInfo.md

@@ -20,8 +20,14 @@ Geeks for Geeks Link: [**Heap Sort**][G4GLink]
 
 [G4GLink]: https://www.geeksforgeeks.org/heap-sort/
 
+## Exercises/Exploration
+
 Many teaching resources say the best case for Heap sort is O(n log n).
 However, there is a case where it is O(n) - can you figure out what it is?
+The AIA progress bar allows you to see how many steps there are in the
+animation, which is a *very rough* guide to run-time. For the best case,
+can you determine a formula for the number of steps taken with 2n data
+items, demonstrating it is O(n)?
 
 Here we have presented the "bottom up" way of creating a heap from an
 unsorted array.  There is also a "top down" method where we start with