18 March

Author: LindaStern

src/algorithms/explanations/AVLExp.md

@@ -1,94 +1,104 @@
 # AVL Trees
 
+
+
 An AVL tree is **self-balancing** **binary search tree**.
 
 Unlike the basic binary search tree, which can exhibit *O(n)* worst case behavior for certain inputs, the AVL tree is always balanced, so search will be *O(log n)*
 regardless of the order of the input data. 
 
 ### The Binary Search Tree Invariant
 
-A **binary tree (BST)** is either is either empty (`Empty`) or else it
+A **binary tree (BST)** is either is either empty (Empty) or else it
 it has a root node and two subtrees (which are binary trees, and can also be empty).
-The root node `t` has a key `t.key`. Ordinarily every node would also
-hold other data (`t.data`), which the user would like to find by
-searching for the key, `e.g.` search for Student ID Number (key) to find street address (data).  
-
-Since the `data` attribute has no impact on 
+The root node t has a key t.key. Ordinarily every node would also
+hold other data (t.data), which the user would like to find by
+searching for the key, *e.g.* search for Student ID Number (key) to find street address (data).  Since the 
+data attribute has no impact on 
 how insertion and search take place, we disregard it in this animation.
-	
 
-Note that a newly inserted node will always appear as a leaf
+
+Note that a newly inserted node 
+will always appear as a leaf
 in the tree. 
+
 		
-In a binary search tree the **BST invariant** is always maintained:\
+In any binary search tree, the **BST invariant** is always maintained; that is,
 for each 
-subtree `t`, with root key `t.key`, the left subtree, `t.left`, 
-contains no node with key greater than `t.key`, and the right subtree,
-`t.right`, contains no node with key smaller than `t.key`.
-
-### AVL tree balancing 
+subtree t, with root key t.key, the left subtree, t.left, 
+contains no node with key greater than t.key, and the right subtree,
+t.right, contains no node with key smaller than t.key.
 
-An AVL tree is **balanced** when the difference in heights of the left and right subtrees is no greater than `1`. 
 
 
+### Insertion and Tree Balancing 
 
-The AVL tree preserves the balance of the tree by (1) checking after every insertion to detect
-when the tree has become unbalanced
-and (2) performing one or more **rotation operations** to restore balance when necessary.
-The imbalance may be located at
-any node along the search path from the root of the tree to the newly inserted node, possibly the grandparent of the newly inserted node, or 
-possibly 
-considerably closer to the root of the tree.
 
+**Insertion of a new item** into any binary tree (*e.g.* a BST or an AVL tree) requires 
+(1) first the search to find the correct place to insert, then (2) the actual insertion. 
 
+In the **recursive implementation** of the AVL shown in *AIA*, the first stage, 
+determining the insertion point, takes place
+during the recursive *calls* to the insert function, which accumulate on the machine stack.  
 
-### Imbalance configurations 
 
-When a new node is inserted in an AVL tree, the tree may become *temporarily* unbalanced. 
-A temporarily unbalanced AVL tree takes on one of two **configurations**, *zig-zag* or *zig-zig*. The 
-sequence of rotations depends on the configuration around the node where the imbalance is detected. 
+The last recursive call *returns* when the new node has been inserted into the tree. 
 
+In the AVL tree, the height of the subtree rooted at each node is stored in the 
+node.During *each* successive *return* from the call to insert,
+the **height of the   is updated** and the **tree is checked for balance**.
+When a new node is inserted in an AVL tree, the tree may become *temporarily* unbalanced, that is 
+the difference in  heights of the left and right subtrees of *any* node is greater than 1.
 
-The **zig-zig** configuration has two mirror-image cases: the child and grandchild nodes or subtrees of the unbalanced node are 
-either (1) both left subtrees or (2) both right subtrees. The **zig-zag** configuration also has two mirror-image cases: the child and grandchild nodes or subtrees of the unbalanced node are 
-either (1) a left subtree and a right subtree or (2) a right subtrees and a left subtree.
 
 
+If the tree has become unbalanced, 
+balance will be restored using one or two **rotation**
+operations, which reduce the height of the unbalanced subtree, while still maintaining the BST invariant.
 
- 
+### Imbalance configurations and rotations
 
-Balance will be restored, using one or two **rotation**
-operations (see below).
+The exact sequence of rotations depends on the configuration around the 
+node where the imbalance has been detected.
 
-### Insertion and rotation
+There are four possible configurations at the node where an imbalance has been detected:
+(1) *left-left*, where the  where the child and grandchild nodes or subtrees of the unbalanced node are 
+either both left subtrees, and (2) its mirror image and *right-right*, where the child and grandchild are both right 
+subtrees; (3) *left-right*, where there is a left child, with a right subtree as the grandchild, and (4) its mirror image 
+*right-left*, where the the right child of the unbalanced node has a left (grand)child.   
 
+The *left-left* imbalance is restored by a single rotation around the edge between the node
+where the imbalance is detected and its (left) child.  Try inserting items 30, 20, then 10 into an AVL tree in *AIA*.  You
+will see that the rotation restores balance, and at the same time maintains the binary search invariant.  Similarly for
+the *right-right* configuration; try inserting 10, 20, then 30 into the *AIA* AVL tree.        
 
 
 
 
-**Insertion of a new item** into any binary tree requires (1) first the search to find the correct place to insert, then (2) the actual insertion. 
+If you try a larger tree
+XXX Lee -- we should come up with a sample tree here, to show imbalance up the tree from the new insert
+XXX Lee -- we can put URLs here, as you suggested. Should we do that for the really simple ones above?
 
-In the **recursive implementation** shown in *AIA*, the first stage, determining  
-the insertion point takes place
-during the *"wind up"* stage of the algorithm, where successive recursive *calls to `insert`* are made and accumulate on the machine stack.  Search does not
-affect the balance of the tree.  During the second stage, however, an imbalance may be introduced into the tree when the new node is actually inserted. The imbalance may be close to the new node, or may be 
-considerably farther up the tree toward the root, along the search path.  Therefore, during each successive *return* from the call to `insert`
- in the "unwind" stage of the algorithm, the height of the node is updated and the tree is checked for balance.  
+As you can see, while 
+**rotation** is a **local operation**, involving only 6 pointer reassignments,
+it can affect the balance of the tree overall.  
 
-When an imbalance is detected, `i.e.` whenever the heights of the subtrees rooted at this node vary by more than `1`, 
-a rotation 
-or rotations are performed in order to bring the tree back into balance.  **Rotation** is a **local operation**, involving only 6 pointer reassignments,
-yet it affects the balance of the tree overall.  
+The *left-right* and *right-left* configurations require a double rotation.  For the *left-right* configuration,
+first a left rotation at the edge between the child and grandchild of the node, and then a right rotation
+at the edge between the node and its now left child (previously grandchild).  The *right-left* configuration requires
+first a right rotation between the child and grandchild, then a left rotation around the node and its (new) right child. 
+You can see how these work by inserting 30,10, then 20 into AIA (*left-right*) and 10, 30, 20 (*right-left*).
 
-Details of the **rotation**, **single** and **double** rotation are found in the AIA tab `More` for this algorithm.  
 
- 
 
 
+XXX Lee -- put these exercises here? or integrated into the text, as I've done for left-left above?
+Only one place, not both
 
-_**Suggested exercises in AIA**_
+_**Suggested exercises in AIA**_  
+XXX Lee - I haven't reviewed these recently, waiting for us to agree on desired  format first.
+XXX In any case, will be rewritten to obliterate zig-zag and friend
 
-To **zig-zig and zig-zag configurations** and **rotation corrections** in AIA: 
 
 -For a left-left zig-zig configuration, enter 50, 40, then with the code expanded enter 30, step by step, to see the temporary left-left zig-zig imbalance, followed by a single rotation.\
 -For right-right zig-zig and single rotation, enter 30, 40, then slowly 50.\

src/algorithms/extra-info/AVLInfo.md

@@ -21,19 +21,22 @@ a:hover{
 Geeks for Geeks Link:
 <a href="https://www.w3schools.com/dsa/dsa_data_avltrees.php" target="_blank">AVL Tree</a>
 
----------------------------------------------------------------
-
-
 Insert detailed information about rotations here.
 
+Rework the following original:
+
 # Rotation in AVL trees
 
-When examining any particular subtree of an AVL tree in AIA, the node we use the following **node numbering scheme** which preserves the binary search invariant, that is, node t1 (with value 1) is always to the left of node t2 (value 2), node t2 is always to the left of node t3 (value 3), node t4 is (value 4) always to the right of node t3.  Importantly, note also that some of these nodes **may be empty**, and are shown for completeness.
+### Node numbering convention
 
-**Lee -- We should talk about whether this numbering makes things more difficult for a student to understand, or easier.**  
+When examining any particular subtree of an AVL tree in *AIA*, we use the following **node numbering scheme** in *AIA*. The nodes are
+labelled `tX`, where `X` is a numeric value, and the binary search invariant is , that is, node t1 (with value 1) is always to the left of node t2 (value 2), node t2 is always to the left of node t3 (value 3), node t4 is (value 4) always to the right of node t3.  Importantly, note also that some of these nodes **may be empty**, and are shown in the diagrams here for completeness.  Note also that generally nodes in *AIA* are identified only by their value; we introduce the numbers tX only when showing rotation.  
+
+  
 
 A full and completely balanced tree, rooted at node would thus be:
-//Comment: need to have empty spaces at the left of this diagram for it to render correctly.
+
+[Comment: need to have empty spaces at the left of this diagram for it to render correctly.]: #)
 
 
         
@@ -43,67 +46,77 @@ A full and completely balanced tree, rooted at node would thus be:
         / \   / \                  
       t1  t3 t5  t7              
 
-The above tree would still be balanced, according to the AVL criterion for balance, if certain nodes or combinations of nodes are empty, for example, t1 or t3 or t5 , or various combinations, such as t1 & t3, or t3 & t5, and so on. The combination t1&t2&t3 would not be allowed, however, as then the tree rooted at t4 would have a left subtree of height 0, and a right subtree with height 2.
+Even if *some* nodes or combinations of nodes were empty, the above tree would still be balanced according to AVL criteria. For example, t1 or t3, or both could be removed, but note that removal of t1 and t2 and t3 would leave the tree unbalanced.
 
+## Correcting the temporarily unbalanced tree
 
-Trees with t1 or t3 or t5 empty, or various combinations, such as t1 & t3, or t3 & t5, and so on, empty would still be balanced, according to the AVL criterion of having a difference in height between two subtrees of no more than 1. 
+Adding a new node may increase the height of some nodes that are closer to the root along the search path.  We show here 
+how a rotation operation, which consists of only a few local pointer reassignments, used to restore the balance of the AVL tree. Importantly,
+although the rotation operation is local, it restores the balance at all the preceding nodes in the search path.
 
 
+In the simplest terms, an edge rotation in a tree is exactly what you would imaging, looking at it visually, and preserves the BST invariant:
 
-In the diagrams below, t6 is the node where the imbalance is noted.    
+Right rotation:
 
-As shown in the diagram below, t6 is the node at which the imbalance has been noted, and t2 is its left child. The clockwise rotation to restore balance makes t2 the parent of t6, while t6 is the *right* child of t2.  Additionally, since t2 already had t4 as its right child, t4 is moved to become the left child of t6.  Note that theBST invariant is preserved: t4, is bigger than t2, and is also smaller than t6.  The rotation reduces the distance from the root to t1 (where the new node was added), so the tree is no
+FIX THIS!!
+      
+      t6                       t2                                t2                                     t6
+     /      Right Rotation      \               and              \            Left Rotation            / 
+   t2     - - - - - - - >       t6                                t6         - - - - - - - >         t2  
 
+ Complications arise with how to handle child nodes.  For example, in the Right Rotation above, what if t2 already has 
+ a right child, making it not so simple to assign t6 as its right child?  Similarly, how do we leave the rotated node 
+ linked to the rest of the tree, if the ancestor of t6 is now t2?
+ 
+ When a new node temporarily unbalances an AVL, the tree can be in one of two configurations, each of which has a mirror image. 
+ The _*left-left*_ case and _*right-right*_ case are mirror images corrected by a single rotation, while the *left-right* and *right-left*
+ case are mirror images corrected by a double rotation.
+ 
+ ## Left-left and Right-right cases (single rotation)
 
+ 
+Below we show a temporarily unbalanced AVL tree, where t6 has been identified as the node where 
+an imbalance is first noted and (as above for Right Rotation) t2 is its left child. Note that some of the nodes may be 
+`empty`.   
 
+First we look at the *left-left* case, where the newly added node is inserted into the subtree rooted at `t1`. The tree is unbalanced at `t6`,
+since its left subtree now has a height of 3, while its right subtree has a height of 1.
 
 
-, as explained in the diagram The 6 and 4 nodes and the edge between them rotate cloc kwise, and
-the 5 node changes parents from 4 to 6. This reduces the distance from
-the root to the 1 (where the new node was added), restoring the balance
-(the distance to the node rooted at 7 is increased but this does not
-cause the AVL tree balance condition to be violated).  Right rotation is
-done by calling rightRotate(t6), where t6 is the tree rooted at 6.
 
-![Alt text if image doesn't open: AVL-left-left](images/AVL/AVL-left-left.jpg){width=120,height=50} This picture is from Greek for Geeks, and is only a placeholder to show proof of concept inserting diagrams, and to check things like size and cropping.
-  
+To restore balance in this *left-left* case,  we perform a *Right Rotation* around the node where the imbalance is detected, `t6` in this case.
+ Node t2 is made the parent of t6, while t6 is now the *right* child of t2.  Additionally, since t2 already had t4 as its right child, but now needs to 
+t4 is moved to become the *left* child of t6, which nicely preserves the BST invariant.   This subtree is now rooted at t2, instead of t6, and is 
+therefore linked into the rest of the tree from this new root.
+ The rotation reduces the distance from the root to t1 (where the new node was added), so the tree is now:   
 
-![Alt text if image doesn't open: AVL-left-left](Linda Stern/GitHub/algorithms-in-action.github.io/src/algorithms/explanationsimag/images/AVL/AVL-left-left.jpg){width=120,height=50} This picture is from Greek for Geeks, and is only a placeholder to show proof of concept inserting diagrams, and to check things like size and cropping.
-  
-Test comment
+       /                                   /   
+      t6                                 t2
+     / \             Right Rotation      / \
+    t2  t7          - - - - - - - >    t1  t6
+   / \             < - - - - - - -         / \
+  t1   t4            Left Rotation       t4  t7
 
-[This shouldn't be seen if the comment signal is correct]: #)
 
-**Check whether the numbering here is still the same in the animation**
-**Note I have added a link to the parent of t6 -- check, since the pointer to the left child of this anonymous node needs to be changed, have we given it a number?** 
+Conversely, for the *right-right* case, looking at t7 as the direct parent of the new node, and t2 as the point at which the
+imbalance is first noted: t7 is the right child of right child `t6`, and we would perform a *Left Rotation*, and shown in the
+same diagram, going from right to left, and implemented as function `leftRotate` in AIA. 
 
-**Lee - is t4 empty in this case?  If not, then the tree would already have been unbalanced  previously, when t4 was added??**
 
-```
-     	/                            /
-      t6                          t2
-     / \     Right Rotation      / \
-    t2   7    - - - - - - - >    1  t6
-   / \       < - - - - - - -       / \
-  1   t4       Left Rotation      t4   7
-```
 
-**9 Jan 4PM I haven't gone beyond this**
+## The left-right  and right-left cases (double rotation)
 
+*I think these diagrams are not consistent with the diagrams in the left-left/right-right section above*
+*Think about it!*
 
-## The right-right case
+Again, these two cases, left-right and right-left, are symmetrical.
 
-The right-right case is the exact opposite. If the tree on the right in
-the diagram above is too unbalanced due to insertion into the subtree
-rooted at 7, we can call rightRotate(t2) to lift that subtree and lower
-the 1 subtree.
+The diagram below illustrates a *left-right* situation, where insertion of a new node into the subtree rooted in node t4 introduces an imbalance into the tree
+that is first noted at node t6. The insertion has been into the *right* subtree (rooted at t4) of a *left* subtree (t2) of `t6`, the node at
+which the dimbalance was first detected.  This situation is corrected by a left rotation at node t2, followed by a right rotation at node t6`, shortening the distance between the new node and the root and rebalancing the tree.  Note that the first rotation turns the left-right configuration to a left-left situation, and the second rotation simply follows as in an outright left-left imbalance.  
 
-## The left-right case (double rotation)
 
-If the new key was added to the right child of the left child (the
-left-right case) and the resulting tree is too unbalanced, the balance can be
-restored with a left rotation at node 2 followed by a right rotation at
-node 6.
 ```
       6      Rotate           6       Rotate           4
      / \    left at 2        / \     right at 6      /   \
@@ -122,7 +135,7 @@ the root of 3, 5 and 7 are changed by one, affecting the overall balance.
 
 If the new key was added to the left child of the right child (the
 right-left case) and the resulting tree is too unbalanced, it is a mirror
-image of the left-right case:
+image of the left-right case.  Insertion into the subtree rooted at `t4`, which is the left child of `t6`, while `t6` is the right child of `t2`, where the imbalance is first detected:
 
 ```
       2      Rotate           2       Rotate           4