Kruskal polishing mostly

Author: lee-naish

src/algorithms/controllers/kruskal.js

@@ -1,5 +1,5 @@
-// Prim's MST algorithm; code copied+modified from Dijkstra's shortest
-// path algorithm animation (might some junk code left over)
+// Kruskal's MST algorithm; code copied+modified from Prim's?
+// (might some junk code left over)
 import GraphTracer from '../../components/DataStructures/Graph/GraphTracer';
 import Array2DTracer from '../../components/DataStructures/Array/Array2DTracer';
 import {colors} from './graphSearchColours';
@@ -134,8 +134,8 @@ export default {
     }
     edges.sort((a, b) => a.weight - b.weight);
 
-    nodes.push('i'); // initialize the display
-    findD.push('find(i)');
+    nodes.push('n'); // initialize the display
+    findD.push('find(n)');
     selectedD.push('Selected');
     costD.push('Cost');
     edgesD.push('Edges');

src/algorithms/explanations/KRUSKALExp.md

@@ -18,14 +18,14 @@ it is ignored, otherwise it is selected to combine the two trees into one.
 
 The forest representation is designed so the checking and combining is
 an instance of the "union-find" problem, for which there are efficient
-algorithms (we don't give details in this animation but present them
-elsewhere). As well as the set of selected edges (which is returned
-at the end), there is a set of sets of nodes that are connected by
-selected edges (the inner sets are the sets of nodes in each tree of
-the forest).  Selecting a new edge combines two trees and this is a
-union operation. Checking if two nodes are in the same tree can be done
-by using the find operation for each node, returning a representative
-node for each tree, and seeing if they are the same.
+algorithms (we don't give details in this animation but present them as a
+separate animation).  Each tree is represented as a set of nodes (thus,
+the forest is represented by a set of sets).  Initially, the inner sets
+are singletons, one for each node in the graph.  Checking if two nodes
+are in the same tree is done by calling the *find* operation for each
+of the two nodes, returning a representative node for each tree, and
+seeing if they are the same.  Adding a new edge, connecting two trees
+in the forest, is done with a *union* operation on the two sets.
 
 Here we number all nodes for simplicity so we can use arrays for the graph
 representation, sets of integers for union-find, etc.  For consistency

src/algorithms/extra-info/KRUSKALInfo.md

@@ -37,4 +37,7 @@ use the existing code to find the second one by re-numbering the graph nodes?
 For Graph1 with the other weight options, can you convince yourself that
 there is a single minimum spanning tree?
 
-
+The animation shows a sorted list of edges, used to select edges in
+order of increasing weight/cost. What is the disadvantage of using a
+sorted list? What are some alternatives that could be used and how do
+they compare?

src/algorithms/pseudocode/HashingInsertion.js

@@ -152,8 +152,9 @@ const main = `
             InsertAll
             For each key k1 in OldT \\B 31
             \\In{
-              HashInsert(T, k1) // recursive! \\B 32
-              \\Expl{ There will never be multiple levels of
+              HashInsert(T, k1) \\B 32
+              \\Expl{ Note: this call is recursive but there will never
+                be multiple levels of
                 recursion because the new table will be large enough
                 to easily accomodate all the keys that were in T.
                 We don't animate the details of these insertions.

src/algorithms/pseudocode/kruskal.js

@@ -30,13 +30,13 @@ Kruskal(G)  // Compute minimum spanning tree for graph G \\B Kruskal(G)
         \\Expl}
         \\Note{highlight edge + trees for n1, n2?
         \\Note}
-        if n1 and n2 are in different trees \\Ref DifferentTrees
+        if n1 and n2 are in different trees/sets in NodeSets \\Ref DifferentTrees
         \\In{
             Add e to Selected \\B addSelected
             \\Expl{ The counter used to keep track of size(Selected)
                 can be incremented here.
             \\Expl}
-            union(NodeSets, n1, n2) // update NodeSets, combining n1&n2 \\B union
+            union(n1, n2) // update NodeSets, combining n1&n2 \\B union
             \\Expl{ This is a union-find operation that takes the union
                 of the sets containing n1 and n2, respectively, since
                 they are now connected by a selected edge.
@@ -68,22 +68,26 @@ Init
         from the while loop significantly earlier in some cases.
     \\Expl}
     NodeSets <- set of singleton sets with each node in G \\B initNodeSets
-    \\Expl{ NodeSets is a set of sets of nodes that are connected by
-        selected edges (like a forest but without information about
-        which edges are used to connect the nodes of each tree).
-        Initially there are no selected edges so we have singleton sets.
+    \\Expl{ NodeSets represents the structure of the forest: which nodes
+        are connected to each other (but without information about which
+        edges are used). Each tree is represented as a just set of nodes;
+        the forest is a set of sets. A "union find" data structure is
+        used for efficiency.  All nodes in the same set/tree return the
+        same result for the find() function. Initially there are no
+        selected edges so each set/tree contains a single node and
+        find() thus returns a different value for each node.
     \\Expl}
 \\Code}
 
 \\Code{
 DifferentTrees
     \\Note{highlight find(n1), find(n2)?
     \\Note}
-    if find(NodeSets, n1) != find(NodeSets, n2) \\B DifferentTrees
+    if find(n1) != find(n2) \\B DifferentTrees
     \\Expl{ Find is a union-find operation that returns a representative
-        element of a set containing a given element. If the elements
+        element of a set in NodeSets containing a given element. If the elements
         returned for n1 and n2 are not equal, it means they are not
-        in the same set, so they are not connected by selected edges.
+        in the same set/tree, so they are not connected by selected edges.
     \\Expl}
 \\Code}