AVL Trees

• Named for the inventors Adel'son Vel'skii and Landis
• A binary search tree with an added property
• SO IT HAS THE BST property.
• Height-Balance Property
  • For every internal node of v of T, the height of the children of v differ by at most 1.
  • This will force the tree to behave nicely.
  • And allow the height to be bound by lg n
  • Note a subtree of an AVL tree is an AVL tree.
• Inserting into an AVL tree
  • If we just insert, we may violate the Height Balance Property
  • A tree is balanced if |h(leftchild) - h(rchild)| <= 1
  • 
  • Otherwise it is unbalanced
  • 
  • If we add a node to a tree, it may become unbalanced.
  • We will then need to fix the tree.

  • Let w be the node that was added that unbalanced the tree
    
    let z be the first node from w towards the root 
         where the tree is unbalanced
    
    let y be the child of z with the greater height
    
    let x be the child of y with the greater height, 
        if there is a tie, choose the ancestor of w
    
    Adding the element to the subtree in y caused the tree
        to become unbalanced, and it now  has height 2 greater
        than the other subtree of z.
    
    

  • What we really want to do now is rotate the tree about x or y, making x or y the new root of the subtree.
  • 
  • A second example:
  • 
  • We may need to move some of the subtrees around.
  • 
  • In this case, we re-parent the left subtree of y to be the right subtree of z. There are 4 possible ways to do this y is the right child of z
    • y is the right child of z
      • x is the right child of y (Case 1)
        • 
        Remember, z is where the tree is unbalanced, so it must move down
        • z must be on the right of y because (by the BST property) z <= y
        • The height of y will become one less, and the height of z will become one more
        • Thus the AVL property will be maintained.
      • x is the left child of y (Case 2)
        • 
        • Remember again, z is out of balance
        • If we move y up, we will have BST problems with x
        • So rotate once among x, remember x is the largest subtree of y so this will maintain the AVL tree property here. (h(T₄) <= h(x))
        • But we haven't fixed z yet, so rotate about x.
    • y is the left child of z
      • x is the left child of y (Case 3, The same as case 1)
      • x is the right child of y (Case 4, The same as case 2)
  • In case 1 and 3, y is between z and x in an in order transversal
    • so make y the root of the new tree.
    • In each case the non-x child of y will become a child of z
    • Some notes for me to remember this by.
  • In case 2 and 4, x is between z and y in an inorder traversal
    • so make x the new root of the subtree
    • In each case, one child of x will go to y and another will go to z
  • No matter what, the non-y subtree of z will gain a height of 1
  • And the y subtree of z will lose one from their heights.
  • Yuck, but one of these will do.
  • And it is O(1).
• Deleting
  • Deleting is the same as inserting.
  • We can follow the binary tree remove routine.
  • But we may unbalance the tree, so we will have to rotate it back into balance.
  • From the node, find the first unbalanced sub tree
  • Rotate that to restore that subtree
  • This may mess up the tree containing this node, so we may need to do this again, the entire way up the tree.
  • But the rotation is O(1), and we may have an O(lgn) trip up the tree.
• Some notes:
  • Store the height at each node.
  • Fix it when the node is rotated.
  • Performance:
    • Insert O(lgn)
    • Delete O(lgn)
    • Find O(lgn)