Minor improvments on AVL trees.

Author: Clément

source/code/projects/AVLTree/AVLTree/AVLTree.cs

@@ -25,13 +25,13 @@ public int Height
     }
 
     public Node(
-      T d = default(T),
+      T dataP = default(T),
       Node leftP = null,
       Node rightP = null,
       int heightP = 0
     )
     {
-      Data = d;
+      Data = dataP;
       left = leftP;
       right = rightP;
       Height = heightP;
@@ -96,9 +96,7 @@ private int UpdateHeight(Node nodeP)
     return height;
   }
 
-  private int SubtreeBalance(Node nodeP)
-  {
-    // Will return
+    // The following will return
     // a negative number if subtree is right-heavy
     // a positive number if subtree is left-heavy
     // 0 if the subtree is perfectly balanced.
@@ -107,6 +105,8 @@ private int SubtreeBalance(Node nodeP)
     // less than or equal to -2.
     // Stated differently, if the value returned is
     // -1, 0 or 1, then no re-balancing will take place.
+    private int SubtreeBalance(Node nodeP)
+  {
     UpdateHeight(nodeP.left);
     UpdateHeight(nodeP.right);
     int balance;
@@ -233,6 +233,18 @@ private Node RotaterightChild(Node nodeTop) // Aka right-right rotation
 *       D       C
 *              / \
 *             F   G
+*
+* The simplified version is:
+* Before:
+*        A
+*       /
+*       B
+*       \
+*        E
+* After:
+*        E
+*       / \
+*      B   A
 */
 
   private Node DoubleleftChild(Node nodeP)
@@ -292,7 +304,7 @@ private Node Insert(T valueP, Node nodeP)
       throw new ApplicationException(
         "Tree did not insert "
           + valueP
-          + " since an item with that value is already in the tree"
+          + " since an item with that value is already in the tree."
       );
     }
 
@@ -450,4 +462,4 @@ private string Stringify(Node nodeP, int depth)
     }
     return returned;
   }
-}
+}

source/diag/gra/bstree_example_10.txt

@@ -0,0 +1,8 @@
+%%% A left-left heavy binary search tree
+
+A((10))-->B((5))
+A-->C((20))
+B-->D((4))
+B-->E((6))
+D-->F((2))
+D~~~H1:::hidden

source/diag/gra/bstree_example_6.txt

@@ -1,4 +1,4 @@
-%%% The binary search tree obtained by inserting 1, 2, …, 1000 (in that order).
+%%% The binary search tree obtained by inserting 1, 2, …, 100 (in that order).
 
 A((1))~~~H1:::hidden
 A-->B((2))

source/diag/gra/bstree_example_7.txt

@@ -1,4 +1,4 @@
-%%% A balanced binary search tree containing 1, 2, …, 1000.
+%%% A balanced binary search tree containing 1, 2, …, 100.
 
 A((64))-->B((32))
 A-->C((80))

source/diag/gra/bstree_example_8.txt

@@ -0,0 +1,7 @@
+%%% An almost unbalanced binary search tree 
+
+A((10))-->B((5))
+A-->C((20))
+B-->D((4))
+B-->E((6))
+

source/diag/gra/bstree_example_9.txt

@@ -0,0 +1,8 @@
+%%% A left-right heavy binary search tree
+
+A((10))-->B((5))
+A-->C((20))
+B-->D((4))
+B-->E((6))
+E~~~H1:::hidden
+E-->F((7))

source/lectures/data/AVLtrees.md

@@ -22,7 +22,7 @@ The resulting tree would be much more efficient if we were leveraging the proper
 
 This is precisely the point of AVL trees, which are binary search trees with the additional property:
 
-> The heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property.
+> The heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, re-balancing is done to restore this property.
 
 where 
 
@@ -33,6 +33,25 @@ A good way of [remembering the difference](https://stackoverflow.com/q/2603692)
 
 ## Possible Implementation
 
+The main challenge is to "re-balance" the tree when needed.
+To determine if a tree needs to be re-balanced, one has to compute its "balance factor", obtained by substracting the right subtree height from the left subtree height. This is done below in the `SubtreeBalance` method.
+
+Consider the following:
+
+!include diag/gra/bstree_example_8.md
+
+After inserting 2, the tree becomes:
+
+!include diag/gra/bstree_example_10.md
+
+which needs to be re-balanced using the `RotateleftChild` method given below. Indeed it is "left-heavy", on the left-hand side (because the left sub-tree, with root 5, is deeper, because of its left side).
+
+If, re-using the same example, we insert 7, then the tree becomes: 
+
+!include diag/gra/bstree_example_9.md
+
+which needs to be re-balanced using the `Doubleleftchild` method given below. Indeed it is "left-heavy", on the right-hand side (because the left sub-tree, with root 5, is deeper, because of its right side).
+
 ### Storing the height in the node
 
 ```{download="./code/projects/AVLTree.zip"}
@@ -43,4 +62,3 @@ A good way of [remembering the difference](https://stackoverflow.com/q/2603692)
 
 It is also possible to compute the height of nodes "on the fly" instead of storing it.
 [This archive](./code/projects/AVLTree_I.zip) demonstrates this concept while additionally inheriting from the `BTree` class [explored previously](./lectures/data/trees).
-