Explaning other iteration of AVLtree.

Author: Clément

source/code/projects/AVLTree_I/AVLTree/BSTree.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-public class BSTree<T> : BTree<T>
+public class BSTree<T> : IBTree<T>
   where T : IComparable<T>
 {
   // Inserting into a BSTree

source/code/projects/AVLTree_I/AVLTree/BTree.cs

@@ -83,7 +83,9 @@ public bool IsEmpty()
   // its root node.
   public int Height()
   {
-    int height = 0;
+    int height = -1;
+    // By convention, an empty tree
+    // will have a height of -1.
     if (root != null)
     {
       height = root.Height;

source/code/projects/AVLTree_I/AVLTree/IBtree.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+
+public abstract class IBTree<T> : BTree<T>
+  where T : IComparable<T>
+{
+  protected int SubtreeBalance(Node nodeP)
+  {
+    // 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.
+    int balance;
+    if (nodeP == null)
+    {
+      balance = 0;
+    }
+    else if (nodeP.left == null && nodeP.right == null)
+    {
+      balance = 0;
+    }
+    else if (nodeP.left == null)
+    {
+      balance = -(nodeP.right.Height + 1);
+    }
+    else if (nodeP.right == null)
+    {
+      balance = nodeP.left.Height + 1;
+    }
+    else
+    {
+      balance = nodeP.left.Height - nodeP.right.Height;
+    }
+    return balance;
+  }
+
+  /*
+   * Before
+   *   nodeTop --> A
+   *              / \
+   * nodeLeft--> B   C
+   *            / \
+   *           D   E <-- nodeLeft.right
+   *
+   * After
+   *             B
+   *            / \
+   *           D   A
+   *              / \
+   *             E   C
+   */
+  protected Node RotateleftChild(Node nodeTop) // Aka left-left rotation
+  {
+    Node nodeLeft = nodeTop.left;
+    nodeTop.left = nodeLeft.right;
+    nodeLeft.right = nodeTop;
+    return nodeLeft; // attached to caller as the new top of this subtree
+  }
+
+  /*
+   * Before
+   *     nodeTop --> A
+   *                / \
+   *               B   C <-- nodeRight
+   *                  / \
+   *                 D   E
+   *
+   * After
+   *           C
+   *          / \
+   *         A   E
+   *        / \
+   *       B   D
+   */
+  protected Node RotaterightChild(Node nodeTop) // Aka right-right rotation
+  {
+    Node nodeRight = nodeTop.right;
+    nodeTop.right = nodeRight.left;
+    nodeRight.left = nodeTop;
+    return nodeRight; // attached to caller as the new top of this subtree
+  }
+
+  /*
+   * Before
+   *     nodeP -->  A
+   *              /   \
+   *             B     C
+   *            / \   / \
+   *           D   E F   G
+   *
+   * After RotaterightChild
+   *           A
+   *          / \
+   *         E   C
+   *        /   / \
+   *       B   F   G
+   *      /
+   *     D
+   *
+   * After
+   *           E
+   *          / \
+   *         B   A
+   *        /     \
+   *       D       C
+   *              / \
+   *             F   G
+   */
+
+  protected Node DoubleleftChild(Node nodeP)
+  {
+    nodeP.left = RotaterightChild(nodeP.left);
+    return RotateleftChild(nodeP);
+  }
+
+  protected Node DoublerightChild(Node nodeP)
+  {
+    nodeP.right = RotateleftChild(nodeP.right);
+    return RotaterightChild(nodeP);
+  }
+
+  // Helper methods, to demonstrate
+  // tree rotations.
+  public void Doubleleft()
+  {
+    if (root != null)
+    {
+      root = DoubleleftChild(root);
+    }
+  }
+
+  public void Doubleright()
+  {
+    if (root != null)
+    {
+      root = DoublerightChild(root);
+    }
+  }
+
+  public void Rotateright()
+  {
+    if (root != null)
+    {
+      root = RotaterightChild(root);
+    }
+  }
+
+  public void Rotateleft()
+  {
+    if (root != null)
+    {
+      root = RotateleftChild(root);
+    }
+  }
+
+  // The ToString method is simply here to help us debug.
+  // It is not really pretty, but using pre-order and spaces
+  // to make it easier to understand how the tree is
+  // constructed. It also displays the height of the tree.
+
+  public override string ToString()
+  {
+    string returned = "Tree height: " + Height() + "\n";
+    int tBalance = SubtreeBalance(root);
+    returned += "Tree balance: " + tBalance;
+    if (tBalance <= -2)
+    {
+      returned += " (Right-heavy)";
+    }
+    else if (tBalance >= 2)
+    {
+      returned += " (Left-heavy)";
+    }
+    returned += "\n";
+
+    if (root != null)
+    {
+      returned += Stringify(root, 0);
+    }
+    return returned;
+  }
+
+  private string Stringify(Node nodeP, int height)
+  {
+    string returned = "";
+    if (nodeP != null)
+    {
+      for (int i = 0; i < height; i++)
+      {
+        returned += " ";
+      }
+      returned += nodeP + "\n"; // Calls Node's ToString method.
+      if (nodeP.left != null)
+      {
+        returned +=
+          "L"
+          + " (h: "
+          + nodeP.left.Height
+          + ")"
+          + Stringify(nodeP.left, height + 1);
+      }
+      if (nodeP.right != null)
+      {
+        returned +=
+          "R"
+          + " (h: "
+          + nodeP.right.Height
+          + ")"
+          + Stringify(nodeP.right, height + 1);
+      }
+    }
+    return returned;
+  }
+}

source/code/projects/AVLTree_I/AVLTree/Program.cs

@@ -47,15 +47,5 @@ static void Main()
     );
     bstree1.Doubleleft();
     Console.WriteLine(bstree1);
-
-    /*
-    Console.WriteLine("Test");
-    AVLTree<int> test = new AVLTree<int>();
-    for (int i = 1; i <= 100; i++)
-    {
-        test.Insert(i);
-    }
-    Console.WriteLine(test);
-    */
   }
 }

source/lectures/data/AVLtrees.md

@@ -61,4 +61,9 @@ which needs to be re-balanced using the `Doubleleftchild` method given below. In
 ### Computing the height on the fly
 
 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).
+
+[This archive](./code/projects/AVLTree_I.zip) demonstrates this concept while additionally
+
+- inheriting from the `BTree` class [explored previously](./lectures/data/trees),
+- adding an `IBTree` class that allows you to explore the re-balancing methods more freely,
+- containing some examples showcasing how re-balancing works.