CS 261 – Data Structures AVL Trees

Binary Search Tree: Balance Complexity of BST operations: proportional to the length of the path from the root to the node being manipulated In a well balanced tree, the length of the longest path is roughly log n –E.g.: 1 million entries  longest path is log 2 1,048,576 = 20. For a thin, unbalanced tree, operations become O(n): –E.g.: elements are added to tree in sorted order BALANCE IS IMPORTANT!

Requiring Complete Trees (Bad Idea) Recall that a complete binary tree has the shortest overall path length for any binary tree –The longest path in a complete binary tree with n elements is guaranteed to be no longer than ceiling(log n) –If we can keep our tree complete, we’re set for fast search times Very costly to maintain a complete binary tree

Height Balanced Trees Instead, use height-balanced binary trees: for each node, the height difference between the left and right subtrees is at most one Trees are locally balanced, but globally they can be slightly more unbalanced

Height-Balanced Trees Mathematically, the longest path in a height-balanced tree is, at worst, 44% longer than log n This is just a constant multiplier (so it is not significant in terms of asymptotic complexity) Therefore, algorithms on height-balanced trees that run in time proportional to the path length are still O(log n) (Proof is sort of cute, ties heights to Fibonocci numbers)

AVL Trees Named after the inventors’ initials Maintain the height balanced property of a BST AVL trees add an integer height field to each node: –null node has a height of –1 –A node is unbalanced when the absolute height difference between the left and right subtrees is greater than one How does it maintain the height balanced property? –When unbalanced, performs a rotation to balance the tree 1 (2) Node data Height field 3 (0) 2 (1) 1 (2) 3 (0) 1 (0) 2 (1) Rotate left Unbalanced node

AVL Implementation: AVLNode - heights struct avlNode { // Inner node class. EleType value;... int height; }; int h(struct avlNode * current) { if (current == nil) return -1; return current->height; } void setHeight(struct avlNode * current) { int lch = h(current->leftChild); int rch = h(current->rightChild); if (lch height = 1 + rch; else current->height = 1 + lch; }

AVL Implementation: Rotations struct avlNode * rotateLeft(struct avlNode * n) { // Rotate node left. struct avlNode *newtop = n->right; // Right child becomes new “top” node. n->right = newtop->left; // Old right child’s left child becomes new right child. newtop->left = n; // new top left child is old top. setHeight(n); // Reset the height of the interior node. setHeight(newtop); // Reset the height of the top node. return newtop; } struct avlNode * rotateRight (struct avlNode * n) {.. // is similar } 3 (0) 2 (1) 1 (2) 3 (0) 1 (0) 2 (1) Rotate left

AVL Trees: Rotation Pseudocode Pseudocode to rotate current (“top”) node left: 1.New top node is the current node’s right child 2.Current node’s new right child is the new top node’s (old right child’s) left child 3.New top’s left child is the current node 4.Set height of current node 5.Set height of new top node 6.Return new top node 1 (0) 2 (3) 6 (0) 3 (0) 4 (2) 5 (1) 1 (0) 2 (1) 6 (0) 3 (0) 4 (2) 5 (1) Rotate left Current “top” node New “top” node

AVL Trees: Double Rotation Sometimes a single rotation will not fix the problem : –Happens when an insertion is made on the left (or right) side of a node that is itself a heavy right (or left) child 2 (0) 1 (2) Unbalanced “top” node 3 (1) “Heavy” right child 2 (0) 3 (2) 1 (1) Rotate left Doesn’t work!!!

AVL Trees: Double Rotation Sometimes a single rotation will not fix the problem : –Happens when an insertion is made on the left (or right) side of a node that is itself a heavy right (or left) child Fortunately, this case is easily handled by rotating the child before the regular rotation: 1.First rotate the heavy right (or left) child to the right (or left) 2.Rotate the “top” node to the left (or right) 2 (0) 1 (2) Unbalanced “top” node 3 (1) “Heavy” right child Rotate heavy child right 3 (0) 2 (1) 1 (2) 3 (0) 1 (0) 2 (1) Rotate top node left

AVL Trees: Balacing Pseudocode Balancing pseudocode (to rebalance an unbalanced node) : If left child is tallest: If left child is heavy on the right side: // Double rotation needed. Rotate the left child to the left Rotate unbalanced (“top”) node to the right Else: // Right child is the tallest. If right child is heavy on the left side: // Double rotation needed. Rotate the right child to the right Rotate unbalanced (“top”) node to the left Return new “top” node

3 (3) 9 (0) 1 (0) 8 (2) 2 (1) 4 (0) 5 (1) 6 (0) AVL Trees: Double Rotation Example Add data: 7 Balanced Tree “Heavy” left child Unbalanced Tree 3 (4) 9 (0) 1 (0) 8 (3) 2 (1) 4 (0) 5 (2) 7 (0) 6 (1) Added to right side of heavy left child Unbalanced “top” node

Tree Still Unbalanced 3 (4) 9 (0) 1 (0) 8 (3) 2 (1) 4 (0) 5 (2) 7 (0) 6 (1) Single rotation AVL Trees: Double Rotation Example Unbalanced Tree 3 (4) 1 (0) 2 (1) 7 (0) 6 (1) 9 (0) 8 (2) 5 (3) 4 (0) Unbalanced “top” node (still)

Tree Still Unbalanced, but … Rotate heavy child AVL Trees: Double Rotation Example “Heavy” left child 3 (4) 9 (0) 1 (0) 8 (3) 2 (1) 4 (0) 5 (1) 7 (0) 6 (2) 3 (4) 9 (0) 1 (0) 8 (3) 2 (1) 4 (0) 5 (2) 7 (0) 6 (1) Unbalanced Tree

Tree Now Balanced Rotate top node AVL Trees: Double Rotation Example Unbalanced Tree (after 1 st rotation) 3 (3) 1 (0) 2 (1) 7 (0) 3 (4) 9 (0) 1 (0) 8 (3) 2 (1) 4 (0) 5 (1) 7 (0) 6 (2) Unbalanced “top” node 4 (0) 5 (1) 6 (2) 9 (0) 8 (1)

AVL Trees head to head with skip lists How do they compare to skip lists? Usually faster And, they use less memory There are other types of height balanced trees. The JAVA library uses red/black trees (class TreeSet). Similar idea, slightly faster still.

AVL Trees: Tree Sort Deja Vu An AVL tree can easily implement SortAlgorithm : 1.Copy the values of the data into the tree 2.Copy them out using an in-order traversal Execution time  O(n log n): –Matches that of quick sort in benchmarks –Unlike quick sort, AVL trees don’t have problems if data is already sorted or almost sorted (which degrades quick sort to O(n 2 )) However, requires extra storage to maintain both the original data buffer (e.g., a dyArray ) and the tree structure

Now Your Turn Any Questions Going to do a quick overview of a few other types of trees we won’t be looking at, Then do worksheet Start by showing AVL insertions of 1 to 7 into an empty tree