AVL Trees

• Named for the inventors Adel'son-Vel;skii and Landis
• A binary search tree with an added property
• Height-Balence 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.
• The height of an AVL tree T for storing n itmes is O(lg n)
  • This is done by bounding the number of nodes in a tree by it's height (rather than bounding the height by the number of nodes in the tree)

    let n(h) be a function that given the height h, 
    returns the minimal  number of internal  nodes.
    
    n(1) = 1, a tree of height 1 must have 
         at least a root and a child of the root
    n(2) = 2, by the same argument.
    
    if h >= 3, and assume the tree contains the 
         minimum number of internal nodes.
         one subtree must have height h-1  (because the root adds
                                                 one to the height)
         and the other height h-2 (Height Balence Property)
    
    so for h >= 3
         n(h) = 1 + n(h-1) + n(h-2)
    since this function n(h) is strictly increasing
         n(h) > n(h-2) + n(h-2)
              > 2n(h-2)
         n(h-2) > 2n(h-2-2) = 2n(h-4)
         n(h) > 2*(2n(h-4)) = 22n(h-2*2)
         n(h-4) > 2n(h-4-2) = 2n(h-6)
         n(h) > 2*(22n(h-2*2-2) = 23n(h-2*3)
    
         or in general
         n(h) > 2in(h-2*i)
    
         so find a value for i where h-2i is 1 or 2 (base case above)
    
         i = ceil(h/2)-1
    
         substuting this back in gives
    
         n(h) > 2h/2 -1
         taking the log of both sides gives us
    
         lg n(h) > h/2 -1
         or h < 2*(lg n(h))+2
    
         which gives us the bound on the height of an AVL tree.
    	

• Inserting into an AVL tree
  • If we just insert, we may violate the Height Balence Property
  • A tree is balenced if |h(leftchild) - h(rchild)| < 1
  • Otherwise it is unbalenced
  • If we add a node to a tree, it may become unbalenced.
  • We will then need to fix the tree.

  • Let w be the node that was added that unbalenced the tree
    
    let z be the first node from the w towards the root 
         where the tree is unbalenced
    
    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 unbalenced, 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.
    
    We may need to move some of the subtrees around.
    
    There are 4 possible ways to do this, and all 4 are illustrated
    on page 431
        y is the right child of x
           x is the right child of y  (case 1)
           x is the left child of y   (case 3)
        y is the left child of z
           x is the left child of y   (case 2)
           x is the right child of y  (case 4)
    
    In case 1 and 2, y is between z and x in an inorder 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
    
    In case 3 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 unbalence the tree, so we will have to rotate it back into balence.
  • From thenode, find the first unbalenced 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)