Broken?? AVL rotation node positions

Author: lee-naish

package-lock.json

@@ -60,6 +60,44 @@ export default {
             }
         }
 
+        /**
+        * compute node positions during rotation
+        * given x-y coordinates of the root and the child, compute the
+        * intermediate position after step 1 or step 2
+        * coords represented as record with fields rX, rY, cX, cY (root X&Y,
+        * child X&Y)
+        * We keep the edge the same length and rotate it around the point 40%
+        * along the edge from the root.  If initially the y coordinate of the
+        * root is 1 and the child is zero, after step 1 the root is at 2/3
+        * and the child is at 1/2 and after step 2 the root is at 1/3 and the
+        * child is at 1.  The x coordinates are computed so as to keep the length
+        * of the edge same (magic numbers derived from maths).
+        * returns record with new coordinates
+        */
+        function rotateStep(pos0, step) {
+
+        let {rX, rY, cX, cY} = pos0;
+	let deltaX = rX - cX;
+	let deltaY = rY - cY;
+        // edge length = sqrt(deltaX**2 + deltaY**2)
+	let deltaX1; // deltaX for new position
+	let pos1 = {rX:0, rY:0, cX:0, cY:0};
+        if (step == 1) {
+            pos1.rY = (2*rY + cY) / 3;
+            pos1.cY = (rY + cY) / 2;
+            deltaX1 = Math.sqrt((35/36)*deltaY**2 + deltaX**2);
+        } else { // assume step == 2
+            pos1.rY = (rY + 2*cY) / 3;
+            pos1.cY = rY;
+            deltaX1 = Math.sqrt((5/9)*deltaY**2 + deltaX**2);
+        }
+	if (rX > cX)  // reverse direction of deltaX
+            deltaX1 = -deltaX1;
+        pos1.rX = (0.6*rX + 0.4*cX) - 0.4*deltaX1;
+        pos1.cX = (0.6*rX + 0.4*cX) + 0.6*deltaX1;
+        return pos1;
+        }
+
         // We apply the following char notations in our rotation code.
         // It helps code reusability and readability.
         // tNum / charNotation
@@ -116,17 +154,11 @@ export default {
                     let rootNode = vis.graph.findNode(tt6);
                     let leafNode = vis.graph.findNode(tt2);
                     // store the previous height of the root node
-                    vis.graph.storePrevHeight(rootNode.y);
-                    // calculate the new position of the nodes
-                    let newY = (rootNode.y + leafNode.y) / 2;
-                    let moveX = 0;
-                    // avoid overlapping
-                    if ((rootNode.x - leafNode.x) < nodeSize) {
-                        moveX = nodeSize - (rootNode.x - leafNode.x);
-                    }
-                    // set the new position of the nodes
-                    vis.graph.setNodePosition(tt6, rootNode.x + moveX, newY);
-                    vis.graph.setNodePosition(tt2, leafNode.x - moveX, newY);
+                    let pos0 = {rX:rootNode.x, rY:rootNode.y, cX:leafNode.x, cY:leafNode.y};
+                    vis.graph.setRotPos(pos0);
+                    let pos = rotateStep(pos0, 1); // compute new position
+                    vis.graph.setNodePosition(tt6, pos.rX, pos.rY);
+                    vis.graph.setNodePosition(tt2, pos.cX, pos.cY);
                 },
                 [A.key, R.key],
                 depth
@@ -144,14 +176,14 @@ export default {
                     }
 
                     // -- following code is for visualising the rotation step by step --
-                    let rootNode = vis.graph.findNode(tt6);
+                    let rootNode = vis.graph.findNode(tt2);
                     let leafNode = vis.graph.findNode(tt2);
                     // freeze the layout to avoid the nodes moving automatically
                     vis.graph.setPauseLayout(true);
-                    let move = (rootNode.x - leafNode.x) / 5;
-                    // set the new position of the nodes
-                    vis.graph.setNodePosition(tt2, leafNode.x + move, vis.graph.getPrevHeight());
-                    vis.graph.setNodePosition(tt6, rootNode.x - move, rootNode.y + (rootNode.y - leafNode.y) * 0.5);
+                    let pos0 = vis.graph.getRotPos(); // original position
+                    let pos = rotateStep(pos0, 2); // compute new position
+                    vis.graph.setNodePosition(tt6, pos.rX, pos.rY);
+                    vis.graph.setNodePosition(tt2, pos.cX, pos.cY);
                 },
                 [R.key, A.key, D ? D.key : false],
                 depth
@@ -274,19 +306,14 @@ export default {
 
                     // -- following code is for visualising the rotation step by step --
                     // find the position of the nodes in the graph
-                    let rootNode = vis.graph.findNode(tt6);
-                    let leafNode = vis.graph.findNode(tt2);
+                    let rootNode = vis.graph.findNode(tt2);
+                    let leafNode = vis.graph.findNode(tt6);
                     // store the previous height of the root node
-                    vis.graph.storePrevHeight(leafNode.y);
-                    let newY = (rootNode.y + leafNode.y) / 2;
-                    let moveX = 0;
-                    // avoid overlapping
-                    if ((rootNode.x - leafNode.x) < nodeSize) {
-                        moveX = nodeSize - (rootNode.x - leafNode.x);
-                    }
-                    // set the new position of the nodes
-                    vis.graph.setNodePosition(tt6, rootNode.x + moveX, newY);
-                    vis.graph.setNodePosition(tt2, leafNode.x - moveX, newY);
+                    let pos0 = {rX:rootNode.x, rY:rootNode.y, cX:leafNode.x, cY:leafNode.y};
+                    vis.graph.setRotPos(pos0);
+                    let pos = rotateStep(pos0, 1); // compute new position
+                    vis.graph.setNodePosition(tt2, pos.rX, pos.rY);
+                    vis.graph.setNodePosition(tt6, pos.cX, pos.cY);
                 },
                 [A.key, R.key],
                 depth
@@ -304,15 +331,13 @@ export default {
                     }
 
                     // -- following code is for visualising the rotation step by step --
-                    // find the position of the nodes in the graph
-                    let rootNode = vis.graph.findNode(tt6);
-                    let leafNode = vis.graph.findNode(tt2);
                     // freeze the layout to avoid the nodes moving automatically
                     vis.graph.setPauseLayout(true);
-                    let move = (leafNode.x - rootNode.x) / 5;
                     // set the new position of the nodes
-                    vis.graph.setNodePosition(tt6, rootNode.x + move, vis.graph.getPrevHeight());
-                    vis.graph.setNodePosition(tt2, leafNode.x - move, leafNode.y - (rootNode.y - leafNode.y) * 0.5);
+                    let pos0 = vis.graph.getRotPos(); // original position
+                    let pos = rotateStep(pos0, 2); // compute new position
+                    vis.graph.setNodePosition(tt2, pos.rX, pos.rY);
+                    vis.graph.setNodePosition(tt6, pos.cX, pos.cY);
                 },
                 [R.key, A.key, D ? D.key : false],
                 depth

src/algorithms/controllers/AVLTreeInsertion.js

@@ -3,11 +3,12 @@ import parse from '../../pseudocode/parse';
 export default parse(`
     
 \\Note{  REAL specification of AVL tree insertion and search
-XXX draft
+XXX Note: has undergone significant restructure and bookmarks have not been
+renamed according to new structure
 \\Note}
 
 \\Note{  modified from BST - best check actual running BST Real code for
-search and use that
+search and use that  XXX still needs unification with BST
 
 Terminology (might change???)
 For BST we confound t.key and t->key, eg, we have c <- c.left.  Its not
@@ -20,6 +21,7 @@ left(t) = *(t->left) (or Empty)   ?????
 right() similarly
 root(t).key, root(t).height, etc
 left(t).height, etc ???
+XXX maybe use height(t), key(t), left(t), right(t)
 \\Note}
 
 \\Overview{  A binary tree is either is either empty (Empty) or else it

src/algorithms/pseudocode/AVLTreeInsertion.js

@@ -10,7 +10,9 @@ AVLT_Search(t, k)  // return subtree whose root has key k; or NotFound  \\B AVL_
     while t not Empty   \\B while t not Empty
     \\In{
         n = root(t)  \\B n = root(t)
-        \\Note{ Avoids confounding pointers and nodes
+        \\Note{ Avoids confounding pointers and nodes  XXX not worth it???
+            could use key(t), left(t), right(t) below; make as similar to
+            AVLTree code as possible
         \\Note}
         if n.key = k    \\B if n.key = k
         \\In{
@@ -34,4 +36,4 @@ AVLT_Search(t, k)  // return subtree whose root has key k; or NotFound  \\B AVL_
     \\In}
 \\In}
 \\Code}
-`);
+`);

src/algorithms/pseudocode/AVLTreeSearch.js

@@ -67,8 +67,9 @@ class GraphTracer extends Tracer {
     this.istc = false;
     this.radius = null;
 
+    // used in AVL trees
     this.pauseLayout = false;
-    this.prebHeight = 0;  // restore the previous height of the node
+    this.rotPos = {};
   }
 
   /* 
@@ -1180,19 +1181,17 @@ class GraphTracer extends Tracer {
   }
 
   /**
-   * return the previous height of the tree in insertion
-   * @param {int} prebHeight the previous height of the tree
+   * save position of root and child pre-rotation (AVL trees)
    */
-  storePrevHeight(prebHeight) {
-    this.prebHeight = prebHeight;
+  setRotPos(pos) {
+    this.rotPos = pos;
   }
 
   /**
-   * return the previous height of the tree in insertion
-   * @returns {int} the previous height of the tree
+   * return position of root and child pre-rotation (AVL trees)
    */
-  getPrevHeight() {
-    return this.prebHeight;
+  getRotPos() {
+    return this.rotPos;
   }
 }