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 log2 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 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 Alex Abner Angela Abigail Adela Alice Add Adam to tree Adam

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 Balanced Tree 3(3) 2(1) 8(2) 1(0) 5(1) 9(0) 4(0) 6(0)

Height-Balanced Trees Mathematically, the longest path in a height-balanced tree has been shown to be, 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)

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 child 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 Node data 1(2) Height field 1(2) 2(1) Unbalanced node 2(1) Rotate left 1(0) 3(0) 3(0)

AVL Implementation: Node and Height struct AVLNode { TYPE val; struct AVLNode *left; struct AVLNode *rght; int hght; /* Height of node. */ }; int _height(struct AVLNode *cur) { if(cur == 0) return -1 else return cur->hght; } void _setHeight(struct AVLNode *cur) { int lh = _height(cur->left); int rh = _height(cur->rght); if(lh < rh) cur->hght = 1 + rh; else cur->hght = 1 + lh

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

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 Unbalanced “top” node 1(2) 3(2) Doesn’t work!!! 3(1) 1(1) “Heavy” right child Rotate left 2(0) 2(0)

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: First rotate the heavy right (or left) child to the right (or left) Rotate the “top” node to the left (or right) Unbalanced “top” node 1(2) 1(2) 2(1) 3(1) 2(1) “Heavy” right child Rotate heavy child right Rotate top node left 1(0) 3(0) 2(0) 3(0)

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

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

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

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

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

AVL Tree: Comparison with Skip Lists How do AVL trees compare to skip lists? Usually faster And, they use less memory Other types of height balanced trees: JAVA library uses red/black trees (class TreeSet)  Similar idea, slightly faster still

AVL Trees: Sorting An AVL tree can easily sort a collection of values: Copy the values of the data into the tree: O(n log2n) Copy them out using an in-order traversal: O(n) 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(n2)) However, requires extra storage to maintain both the original data buffer (e.g., a DynArr) and the tree structure

Your Turn Any questions Worksheet: Start by inserting values 1-7 into an empty AVL tree Then write code for left and right rotations