1. CS 261 – Data Structures
AVL Trees

2. 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!

3. 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

4. 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)

5. 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)

6. 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)

7. 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

8. 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)

9. 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)

10. 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)

11. 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

12. 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

13. 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)

14. 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)

15. 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)

16. 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

17. 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

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