10/23/2013. AVL Trees. Height of an AVL Tree. Height of an AVL Tree. AVL Trees

Transcription

1 // AVL Trees AVL Trees An AVL tree is a binary search tree with a balance condition. AVL is named for its inventors: Adel son-vel skii and Landis AVL tree approximates the ideal tree (completely balanced tree). AVL Tree maintains a height close to the minimum. Definition: An AVL tree is a binary search tree such that for any node in the tree, the height of the left and right subtrees can differ by at most. Two binary search trees: (a) an AVL tree; (b) not an AVL tree (unbalanced nodes are darkened) Height H of a tree Height of an AVL Tree N(h) = minimum number of nodes in an AVL tree of height h. Basis N() =, N() = Induction N(h) = N(h-) + N(h-) + Solution (from Fibonacci analysis) N(h) > h (.) h- h h- Height of an AVL Tree N(h) > h (.) Suppose we have n nodes in an AVL tree of height h. n > N(h) (because N(h) was the minimum) n > h hence log n > h (relatively well balanced tree!!) h <. log n (i.e., Find takes O(logn))

2 // Properties The depth of a typical node in an AVL tree is very close to the optimal log N. Consequently, all searching operations in an AVL tree have logarithmic worst-case bounds. An update (insert or remove) in an AVL tree could destroy the balance. It must then be rebalanced before the operation can be considered complete. After an insertion, only nodes that are on the path from the insertion point to the root can have their balances altered. Rebalancing Suppose the node to be rebalanced is X. There are cases that we might have to fix (two are the mirror images of the other two):. An insertion in the left subtree of the left child of X,. An insertion in the right subtree of the left child of X,. An insertion in the left subtree of the right child of X, or. An insertion in the right subtree of the right child of X. Balance is restored by tree rotations. Balancing Operations: Rotations Case and case are symmetric and requires the same operation for balance. Cases, are handled by single rotation. Case and case are symmetric and requires the same operation for balance. Cases, are handled by double rotation. Single Rotation A single rotation switches the roles of the parent and child while maintaining the search order. Single rotation handles the outside cases (i.e. and ). We rotate between a node and its child. Child becomes parent. Parent becomes right child in case, left child in case. The result is a binary search tree that satisfies the AVL property. Single rotation to fix case : Rotate right Symmetric single rotation to fix case : Rotate left

3 // Single rotation fixes an AVL tree after insertion of. Example Start with an empty AVL tree and insert the items,,, and then through in sequential order. Answer: Analysis One rotation suffices to fix cases and. Single rotation preserves the original height: The new height of the entire subtree is exactly the same as the height of the original subtree before the insertion. Therefore it is enough to do rotation only at the first node, where imbalance exists, on the path from inserted node to root. Thus the rotation takes O() time. Hence insertion is O(logN) Double Rotation Single rotation does not fix the inside cases ( and ). These cases require a double rotation, involving three nodes and four subtrees. Single rotation does not fix case. Left right double rotation to fix case Lift this up: first rotate left between (k, k ), then rotate right betwen (k,k )

4 // Left-Right Double Rotation Double rotation fixes AVL tree after the insertion of. A left-right double rotation is equivalent to a sequence of two single rotations: st rotation on the original tree: a left rotation between X s left-child and grandchild nd rotation on the new tree: a right rotation between X and its new left child. Right Left double rotation to fix case. insert,,,,,,,, First insert and : AVL balance restored.

5 // AVL violation - rotate AVL balance restored: AVL violation rotate: Now insert. AVL balance restored: Now insert.

6 // AVL violation - rotate Now insert. AVL violation rotate. AVL balance restored: Now insert.

7 // AVL violation rotate. AVL balance restored. AVL violation - rotate. Now insert. AVL balance restored. Now insert and.

8 // AVL violation - rotate. Final tree: Tree is almost perfectly balanced Single right rotation /* * Rotate binary tree node with left child. * For AVL trees, this is a single rotation for case. * Update heights, then return new root. */ AvlNode rotatewithleftchild( AvlNode k ) { AvlNode k = k.left; k.left = k.right; k.right = k; k.height = max( height( k.left ), height( k.right ))+; k.height = max( height( k.left ), k.height ) + ; return k; Double Rotation /* * Double rotate binary tree node: first left child. * with its right child; then node k with new left child. * For AVL trees, this is a double rotation for case. * Update heights, then return new root. */ AvlNode doublewithleftchild( AvlNode k ) { k.left = rotatewithrightchild( k.left ); return rotatewithleftchild( k ); /* Internal method to insert into a subtree. * x is the item to insert. * t is the node that roots the tree. */ AvlNode insert( key x, AvlNode t ) { if( t == NULL ) { return new AvlNode( x, NULL, NULL ); else if ( x < t.element ) { t.left = insert( x, t.left ); if ( height( t.left ) - height( t.right ) > ) if ( x < t.left.element ) t = rotatewithleftchild( t ); else t = doublewithleftchild( t ); else if ( t.element < x ) { t.right = insert( x, t.right ); if( height( t.right ) - height( t.left ) > ) if( t.right.element < x ) t = rotatewithrightchild( t ); else t = doublewithrightchild( t ); else ; // Duplicate; do nothing t.height = max( height( t.left ), height( t.right ) ) + ; return t;

9 // AVL Tree Deletion Similar but more complex than insertion Rotations and double rotations needed to rebalance Imbalance may propagate upward so that many rotations may be needed. Pros and Cons of AVL Trees Pros:. Search is O(log N) since AVL trees are always balanced.. Insertion and deletions are also O(logn). The height balancing adds no more than a constant factor to the speed of insertion. Cons:. Difficult to program & debug; more space for balance factor.. Asymptotically faster but rebalancing costs time.. Most large searches are done in database systems on disk and use other structures (e.g. B-trees).. May be OK to have O(N) for a single operation if total run time for many consecutive operations is fast (e.g. Splay trees).