AVL Trees

Efficiency of Binary Search Tree Operations
- BSTs come in all shapes and sizes. The efficiency of a retrieval operation, deletion or insertion correlates directly with the height of the tree.
- Each search travels from the root to the node with the proper SearchKey or NULL is the node is not in the tree, so the maximum number of comparisons = number of nodes on the longest path through the tree = height of the BST.
- A tree of maximum height is one where each node has at most one child. This resembles a linked list.
- To have the minimum height of a tree, you need to fill in each level as completely as possible.
- The maximum number of nodes that binary tree of height h can have is 2^h - 1. So the minimum height of a tree with N nodes is
```
   the upper bound of log₂(N+1)
```
- The minimum height is the same as the maximum number of comparisons a binary search would need.
- As you move away from a balanced tree to a more linear structure, height approaches N and the maximum comparisons increases with the height of the the tree - ultimately becoming the same as searching a linked list.
- The shape of a binary search tree is determined based on the order of the input data. If it comes in order, you get a tree of maximum height. With more random order of input, the tree tends to be more bushy. Is there a way of guaranteeing a tree close to or at minimum height.?

AVL Trees

2 Russian mathematicians G.M. Adel'son-Vel'skii and E.M. Landis
Goal is that searches, insertions, and deletions in a tree with N nodes can be achieved in time of O(log n), worst case.
height-balanced tree - the difference in height of 2 subtrees of any node is at most 1.
Definition:
An AVL tree is a binary search tree in which the heights of the left and right subtrees of the root differ by at most 1, and in which the left and right subtrees are again AVL trees. With each node of an AVL tree is associated a balance factor which is left high, equal, or right high according, respectively, as to whether the left subtree has height greater than, equal to, or less than that of the right subtree.
An empty tree is height balanced.
Note that the definition does not require that all leaves be on the same or adjacent levels.
More trees with the right high, equal and left high markings.

Insertion into an AVL tree

Can use normal insertion techniques for binary search trees
Often this will not change height nor balance of tree
Even if height changes, may be shorter subtree that grows, so only balance if root changes
**The only case that can cause difficulty occurs when the new node is added to a subtree that is strictly taller than the other and the height is increased.
Conventions:
-each node needs additional field
enum balancefactor {RH,EH,LH};
-need an additional argument of type bool
bool taller;
-returns true if the height of the subtree increased, false otherwise.
If you insert into a subtree so the height is increased to 2 more than the other subtree this no longer satisfies AVL requirements.
You must now rebuild part of the tree to restore its balance
RIGHTBALANCE
CASE 1: Right High - needs left rotation
-x is right high
-rotate node x upward to the root, dropping the root r down into the left subtree of x
-the subtree T2 of nodes with keys between those of r and x now becomes the right subtree of r rather than left subtree of x.
-actually rotate values in 3 pointer variables
-total height is increased by 1.

CASE 2: Left High - needs double rotation
-right subtree is 2 high but the balancefactor of x is left high
-it's necessary to move 2 levels, to the node w that roots the left subtree of x, to find the new root
-called double rotation
-first rotate subtree with root x to the right so 2 becomes its root and then rotating the tree with root r to the left (moving w up to new root)

Code

enum balancefactor {RH,EH,LH};
struct AVLNode{
  treeItemType  key;
  ptrType       LChildPtr;
  ptrType       RChildPtr;
  balancefactor  BF;
};AVLNode


void Insert (ptrType& root, ptrType newItem, bool& taller)
{
  bool tallersubtree;
  if (root == NULL){
    root = newItem;
    root->LChildPtr = NULL;
    root->RChildPtr = NULL;
    root->BF = EH;
    taller = true;
  }
  else if (newItem->key == root->key)
    error;
  else if (newItem->key < root->key){
    insert(root->LChildPtr, newItem, tallersubtree;
    if (tallersubtree){
      switch(root->BF){
        case LH: LeftBalance (root); break;
        case EH: root->BF = LH; taller = true; break;
        case RH: root->BF = EH; taller = false; break;
      }//switch
    else
      taller = false;
  }
  else{
    insert(root->RChildPtr, newItem, tallersubtree);
    if (tallersubtree){
      switch(root->BF){
        case LH: root->BF = EH; taller = false; break;
        case EH: root->BF = RH; taller = true; break;
        case RH: RightBalance(root);
      }//switch
    }
    else
      taller = false;
  }//else
}//insert


void RightBalance (ptrType& root)
{
  ptrType x, w;
  x = root->RChildPtr;
  switch (x->BF){
    case RH : root->BF = EH;
              x->BF = EH;
              RotateLeft(root);
              taller = false;
              break;
    case EH : error;
    case LH : w = x->LChildPTr;
              switch(w->BF){
                EH:root->BF = EH; x->BF = EH; break;
                LH:root->BF = EH; x->BF = RH; break;
                RH:root->BF = LH; x->BF = EH; break;
              }//switch
              w->BF = EH;
              RotateRight(x);
              root->RChildPtr = x;
              RotateLeft(root);
              taller = false;
              break;
  }//switch
}//RightBalance

void RotateLeft(ptrType& ptr)
{
  ptrType temp;
  if (ptr == NULL)
    error;
  else if (ptr->RChildPtr == NULL)
    error;
  else{
    temp = ptr->RChildPtr;
    ptr->RChildPtr = temp->LChildPtr;
    temp->LChildPtr = ptr;
    ptr = temp;
  }//else
}//RotateLeft


void RotateRight(ptrType& ptr)
{
  ptrType temp;
  if (ptr == NULL)
    error;
  else if (ptr->LChildPtr == NULL)
    error;
  else{
    temp = ptr->LChildPtr;
    ptr->LChildPtr = temp->RChildPtr;
    temp->RChildPtr = ptr;
    ptr = temp;
  }//else
}//RotateRight

Deletion of a node x from an AVL tree

Reduce the problem to a case where node x to be deleted has one child.
- find the immediate successor (or predecessor) and copy it into position of node to delete.
- Now delete former pred or succ (guaranteed to have at most one child)
- trace the effects of this change to the height of the tree through all the nodes back to the root.
- you need a boolean variable 'shorter' to show if height of subtree has been changed.
  -shorter is initially true
  -case 1: it becomes false if parent node is initially EH.
  
  -case 2: balancefactor of parent is not equal and longer subtree is shortened. Parent becomes EH and shorter is true.
  
  -case 3: balancefactor of parent is not equal and shorter subtree is made shorter. Need to rebalance.
  1. right double high (p) equal (q) = single rotation, change balancefactors accordingly and shorter is false.
  2. right double high (p) right high (q) = single rotation, balance factors become equal and shorter is true
  3. right double high (p) left high (q) = double rotation around q then p, balance factors of new root is equal, set others, shorter is true.

D. Noonan 3/31/2003