Balanced Trees

Week 9, Wednesday

March 4, 2026

Recap: BSTs

Insert and Find running time are O(______)

Recap: Building a BST

Insert: 10, 13, 25, 38, 40, 51, 84

Build another “bad” tree:

Give an insertion order:

How many bad trees are there?

BST: Height and Data

BST operations depend on the height (\(h\)) of the tree.

But we want to analyze in terms of \(n\) (the amount of data).

So we need relationships between \(h\) and \(n\):

• \(h \geq\) ________
• \(h \leq\) ________

Fill in: - h >= log₂(n) (lower bound — best case, perfectly balanced) - h <= n - 1 (upper bound — worst case, degenerate)

Lower bound is good news (fast operations). Upper bound is bad news (slow operations).

Average Case

The height of a BST depends on the order data is inserted.

How many different insertion orders for \(n\) keys? _____

Average height, over all arrangements of \(n\) keys: ________

Operation	Avg Case	Worst Case
find	\(\Theta(\log n)\)	\(\Theta(n)\)
insert	\(\Theta(\log n)\)	\(\Theta(n)\)
delete	\(\Theta(\log n)\)	\(\Theta(n)\)

• n! different insertion orders
• Average height is O(log n) — this was proven by Reed (2003)
• But worst case is still O(n), and real-world data is often nearly sorted!

Comparing Dictionary Implementations

Structure	Insert	Find	Delete	Sorted Iterate
Unsorted list	O(1)	O(n)	O(n)	O(n log n)
Sorted list	O(n)	O(log n)	O(n)	O(n)
Hash table	O(1) avg	O(1) avg	O(1) avg	Not possible
BST	O(____)	O(____)	O(____)	O(n)

BST answers are O(height) — which is O(log n) average, O(n) worst case.

Why Trees Instead of Hash Tables?

Hash tables give O(1) expected time. Why use trees?

Trees can do things hash tables can’t:

• Sorted iteration: Traverse keys in order
• Range queries: Find all keys between A and B
• Predecessor/successor: Find the next-smallest key
• No hash function needed: Works with any comparable type

Which Tree Makes You Happiest?

 

The height balance of a tree \(T\) is: \(b = \text{height}(T_R) - \text{height}(T_L)\)

A tree \(T\) is height balanced if:

• _______________________________________

• _______________________________________

Fill in: - |b| ≤ 1 for every node in the tree - Both subtrees are also height balanced (recursive!)

Equivalently: every node has balance factor in {-1, 0, 1}.

Lead students to articulate: “balanced” — left and right subtrees are about the same height. Then formalize on next slide.

Rotations on a BST

Balance factors: 50 (b=2), 30 (b=0), 80 (b=2), 20 (b=0), 40 (b=0), 60 (b=0), 90 (b=1), 85 (b=0), 99 (b=-1), 95 (b=0).

Lowest unbalanced node is 80 (b=+2). Its right child 90 has b=+1 → right-right (outer) case → single left rotation at 80. Annotate the rotation on the board.

After left rotation at 80: 90 replaces 80, 80 becomes 90’s left child, 85 moves to become 80’s right child. Result: balanced!

Rotations on a BST

b=-2 at 70, left child 40 has b=+1 (right-heavy). This is a zig-zag (left-right / inner case). Try a single right rotation at 70: 40 becomes root, 70 becomes right child, 50 moves to 70’s left child. Result: 40(20, 70(50(_, 60), 80)) — still b=+2 at 40! The single rotation just moved the problem. We need a double rotation.

The fix (left-right double rotation): Step 1: Left rotate at 40 → 70(50(40(20), 60), 80) Step 2: Right rotate at 70 → 50(40(20), 70(60, 80)) Now balanced!

Rotations on a BST

b=-2 at 70, left child 40 has b=+1 (right-heavy). This is a zig-zag (left-right / inner case). Try a single right rotation at 70: 40 becomes root, 70 becomes right child, 50 moves to 70’s left child. Result: 40(20, 70(50(_, 60), 80)) — still b=+2 at 40! The single rotation just moved the problem. We need a double rotation.

The fix (left-right double rotation): Step 1: Left rotate at 40 → 70(50(40(20), 60), 80) Step 2: Right rotate at 70 → 50(40(20), 70(60, 80)) Now balanced!

Operations on BSTs — Rotations

Rotation properties:

• There are 4 kinds: left, right, left-right, right-left
• Local operations (subtrees not affected)
• Constant time (\(O(1)\))
• BST property maintained

AVL Trees

GOAL: use rotations to maintain balance of BSTs.

These trees have a special name: AVL Trees

Named after Adelson-Velsky and Landis (1962).

AVL Property: For every node, \(|b| \leq 1\).

Three issues to consider in the implementation:

1. Rotation
2. Maintaining height
3. Detecting imbalance

AVL Tree Explorer

Try: insert 1, 2, 3, 4, 5, 6, 7 and watch rotations happen. Compare to what happens in the regular BST explorer with the same sequence. At most ONE rotation (single or double) per insert to restore balance.

Balanced Trees in Practice

Language	Balanced Tree
C++	std::map, std::set (Red-Black)
Java	TreeMap, TreeSet (Red-Black)
Python	sortedcontainers.SortedDict (3rd party)
Databases	B-trees, B+ trees

Python’s built-in dict uses hash tables, not trees.

Summary: Balanced Trees

1. BST operations are O(height) — height matters!

2. Unbalanced BSTs can have O(n) height — bad for sorted input

3. Rotations reshape BSTs while preserving order

4. AVL trees use rotations to maintain \(|b| \leq 1\) for every node

5. Diagnosing: check child’s balance factor to pick the rotation

6. Guarantee: O(log n) height, so O(log n) operations

Practice

1. Is this tree AVL-balanced? (Check every node’s balance factor)

        50
       /  \
      30   70
     /    /  \
    20   60   90
   /
  10

2. If not, which rotation(s) would fix it?

3. After inserting 5, 3, 7, 2, 4, 6, 8 into an empty AVL tree, what does it look like?

(Hint: Use the visualization tool to check!)