AVL Trees – CMPT 225

Recall: A BST is:

• a binary tree
• with nodes labled by keys
• for every two nodes u,v:
  • if u is in the left subtree of v, then key(u) < key(v)
  • if u is in the right subtree of v, then key(u) > key(v)

• BST operations take time proportional to the tree height, which might be the same as the number of keys.

• AVL Trees are a kind of “self-balancing” BST. Tree height is always at most $2 \log_{2} n$ where n is number of keys.
• An AVL Tree is a BST that satisfies the following height-balance invariant:

  • for every node v: $$

    \text{height}(\text{left}(v)) - \text{height}(\text{right(v))

    \leq 1$$ #TODO FIX

  • (We define height(left(v)) = -1 if left(v) does not exist, similarly for right.
• Implementing the Operations:
  1. Perform BST operations, then
  2. repair balance if needed.

How unbalanced can an AVL Tree be?

Ex. A “Maximally unbalanced” height - 5 AVL Tree

• root node
  • left subtree (7 nodes)
    • node
      • node
        • node (left)
      • node
    • node
      • node (left)
  • right subtree (31 nodes)
    • node
      • node
        • node
          • node
          • node
        • node
          • node
          • node
      • node
        • node
          • node
          • node
        • node
          • node
          • node
    • node
      • node
        • node
          • node
          • node
        • node
          • node
          • node
      • node
        • node
          • node
          • node
        • node
          • node
          • node

How tall can an AVL Tree be?

Let N(h) = min # of nodes in an AVL tree of height h.

Observe:

• $$N(0) = 1$$
• $$N(1) = 2$$
• $$N(h) = N(h-1) + N(h-2) + 1$$
• $$N(h) > 2 N(h-2)$$
• $$N(h) > 2 \times 2 N(h-4)$$
• $$N(h) > 2^{3} N(h-6)$$
• …
• $N(h) > 2^{i} N(h-2i)$ (if H is even, we end when $h-2i=0 \implies i = h/2$)
• $$N(h) > 2^{y} \times c = 2^{h/2}\times 1$$

Claim: $N(h) > 2^{h/2}$

Proposition: $N(h) > 2^{h/2}$

• Pf.:
  • By ind. on h.
  • Basis: $N(0)=1 \leq 2^{0} = 1$ (checkmark); $N(1)=2 > 2^{1/2} = \sqrt{2}$ (checkmark).
  • Assume, for some $h\geq 1$, that $N(h)>2^{h/2}$
  • Now $N(h+1) > 2N(h-1) \geq 2\times 2^{\frac{h-1}{2}} = 2^{1+\frac{h-1}{2}} = 2^{\frac{h-1+2}{2}} = 2^{\frac{h+1}{2}}$ (checkmark)
  • So: $N(h)>2^{h/2} \implies \log_{2} N(h) > h/2 \implies h < 2 \log_{2} N(h) \leq 2 \log_{2} n$
  • We have: for every AVL tree with n nodes and height h, $h < 2 \log_{2} n = O(\log n)$
• Thus: AVL Tree search takes time that is $O(\log n)$

Max AVL Tree Height vs BST height

(Worst case # of nodes visited by AVL-tree vs BST search)

$n$	$2 \log_{2} n$
$10$	$7$
$100$	$14$
$1000$	$20$
$10^{4}$	$27$
$10^{5}$	$33$
$10^{6}$	$40$
$10^{7}$	$47$
$10^{8}$	$53$
$10^{9}$	$60$
$10^{10}$	$66$

Unbalanced subtrees are “repaired” using rotations

• 5
  • 3
    • 1
    • 4
  • 7
    • 6
    • 8

Can be converted to the following using a right rotation at node with 5. Can be converted from the following using a left rotation at the node with 3.

• 3
  • 1
  • 5
    • 4
    • 7
      • 6
      • 8

AVL Tree insertion:

1. Do BST insertion.
2. If there is an unbalanced node,
   • let v be the unbalanced node of greatest depth*
   • repair the imbalance at v.

Consider 4 cases (w is new node, v is unbalanced, k is height of tree, h is height of any given subtree):

2 outside cases:

Case 1:

• v (root; h=k)
  • left (h=k-1)
    • left left (h=k-2)
      • ...
        • w
    • left right (h=k-2)
      • ...
  • right (h=k-2)
    • ...

Case 2:

• v (root)
  • left
    • ...
  • right
    • right left
      • ...
    • right right
      • ...
        • w

Case 3:

• v (root)
  • left
    • left left
      • ...
    • left right
      • ...
        • w*
  • right
    • ...

Case 4:

• v (root)
  • left
    • ...
  • right
    • right left
      • ...
        • w*
    • right right
      • ...

* It msut be on the path from the new leaf to the root.

To fix the “ouside” cases:

Do 1 rotation at the unbalanced node.

• v (root; h=k)
  • u (h=k-1)
    • left left (h=k-1)
      • T1 (h=h-2)
        • w
    • T2 (h=k-2)
  • T3 (h=k-2)

After rotation:

• u (root; h=k)
  • T1 (left; h=k-2)
    • w
  • v (right; h=k-1)
    • T2 (right left; h=k-2)
    • T3 (right right; h=k-2)

* The final height of u is k, so the tree is now balanced.

Excersizes:

1. Draw the right-right case in detail.
2. Draw them with minimal sized T1,T2,T3

The “inside cases” are not fixed by this rotation:

• v (root)
  • node (left; h=k-1)
    • T1 (left left; h=k-2)
    • T2 (left right; h=k-2)
      • w
  • T3 (right; h=k-2)

Would become, with a right rotation:

• v (root)
  • T1 (left; h=k-2)
  • node (right; h=k)
    • T2 (right left; h=k-2)
      • w
    • T3 (right right)

(Transcriber’s note: w is now used as a variable by the slides. w will no longer represent the asdded node. This will be written down in full as “new node”.)

To fix the “inside” cases, we use two rotations:

• v (h=k; v is the unbalanced node of any depth; label=a)
  • u (h=k-1; label=b)
    • T1 (h=k-2)
    • w (h=k-2; label=w)
      • T2 (h=k-3)
        • Insertion here or... one other place
      • T3 (h=k-3)
        • Other possible insertion place.
  • T4 (h=k-2)

Left rotation at b:

• a
  • c (h=k)
    • b
      • T1
      • T2
        • possible insertion
    • T3 (h=k-3)
      • possible insertion (not part of height)
  • T4 (h=k-2)

After 1 rotation, this is too tall (like outisde case

Right rotation at a:

• c
  • b (h=k-1)
    • T1 (h=k-2)
    • T2 (h=k-2)
      • possible insertion point
  • a (h=k-1)
    • T3 (h=k-2)
      • possible insertion
    • T4 (h=k-2)

The entire operation is:

1. left(c) <- b
2. right(c) <- a
3. left(a) <- T3
4. right(b) <- T2
5. Change parent(a) to be parent(c)

(#1 rotation = 3 assignments; 2 rotations = 6 assignments; double rot = 5 assignments.)

AVL Tree Removal

1. Do BST Removal.
2. Rebalance.

Define “the parent of the unbalanced node” (*) by cases:

1. The deleted key was at a leaf.
2. The deleted key was at a node with one child.
3. The deleted key is at a node with 2 children.

Case 1 graphs (X is removed node; p is parent of removed node):

• p
  • X (right)

Becomes:

• p

Graphs for case 2:

• p
  • X (right)
    • ... (right)

Becomes:

• p
  • ... (right)

Graphs for case 3:

• X
  • ...
  • node
    • p (left)
      • node (arrow to X)

Or:

• X1
  • ...
  • node
    • p (left)
      • X2 (arrow to X1)
        • ... (right)

---

Fact: After doing a BST removal in an AVL tree, there is at most 1 unbalanced node, and it is on the path from the parent of the deleted node to the root.

(If the deleted node was the root, the “parent of the deleted node” does not exist–but also there can be no unbalanced node)

Consider:

• root
  • ...
    • ...
      • continues on with no detail
      • o (orange)
        • continues on with no detail
        • node
          • b (blue; left)
            • m (mauve)
              • continues on with no detail (right)
            • continues oN with no detail
    • continues on with no detail
  • continues on with no detail

Becomes:

• root
  • ... (g; green)
    • ... (r; red)
      • continues on with no detail
      • o (orange)
        • continues on with no detail
        • node
          • b (blue; left)
            • continues on with no detail
            • continues oN with no detail
    • continues on with no detail
  • continues on with no detail

Terms:

• o, orange: Node with key to be deleted.
• m, mauve: Deleted node
• b, blue: Parent of deleted node
• r, red: Unbalanced node
• g, green: This node, for example, cannot be unbalanced.

An AVL tree removal that illustrates:

1. Need to re-balance after removal
2. Re-balancing node u may reduce the height of a subtree, resulting in an ancestor of u being unbalanced.

remove(14):

• 10 (h=3)
  • 4
    • 2
    • 7
      • 5 (left)
  • 12
    • 14 (removed; right)

left at 4:

• 19
  • 7
    • 4 (left)
      • 2
      • 5
  • 12

right at 10:

• 7
  • 4
    • 2
    • 5
  • 10
    • 12 (right)

Abstract version:

• node
  • node
    • ...
    • ...
      • 5 (left)
  • ...
    • 14 (right; deleted)

Rebalance (for deletion):

• w <- parent of deleted node, if it exists
• for (each node $u = w\cdots \text{root}$ on path from $w\cdots \text{root}$){
  • if u is unbalanced
    • Let T be the subtree rooted at u
    • rebalance T using suitable rotations*
    • if height of T did not get smaller, return
• }

* either a single or a double rotation, based on case diagrams similar to that used for insertion.

Correctness of the algorithm involves two properties:

1. There is at most 1 unbalanced node after deletion.
2. Rebalancing w may make an ancestor of w unbalanced.

Complexity of AVL tree operations

• Every AVL tree with n nodes has height $O(\log n)$.
• The worst case amount of work for main opperations is:
  • search: $O(\log n)$
    • one traversal from root to leaf: $O(\log n)$
  • insert: $O(\log n)$
    • two traversals from root to leaf (down & back up): $O(\log n)$
    • two rotations: $O(1)$
  • remove: $O(\log n)$
    • two traversals from root to leaf (down & back up): $O(\log n)$
    • at most, two rotations at each node on that path: $O(1) \times O(\log n) = O(\log n)$.

All three major operations in $O(\log n)$ time.

End