Advanced Search Trees

After watching the video, read Bailey 14.5 for an overview of one advanced variation of a binary search tree: the splay tree. Optionally read 14.6 for splay-tree implementation details and 14.7 for a description of a type of self-balancing tree: the red-black tree.

An AVL tree (named after inventors Adelson-Velsky and Landis) is a self-balancing binary search tree.

• Structural properties
  • Binary search tree property (nodes to the left are smaller, nodes to the right are larger)
  • NEW: balance property
    • The difference in heights between the left subtree and the right subtree must be at most 1
• Result:
  • Worst-case height is \(O(\log n)\)

A valid AVl tree (blue numbers are the height at each node):

Not a valid AVL tree (red height numbers indicate nodes with children out of balance)

How do we enforce the balance property?

• As we insert and delete elements, we need to:
  • Track balance
  • Detect imbalance
  • Restore balance

We will need to store height at each node:

Searching the tree works exactly the same as it does for a BST For adding

• we first add as normal for a BST
• then fix any resulting imbalance

More specifically,

• Insert the new node as in a BST (a new leaf)
• For each node on the path from the root to the new leaf, the insertion may (or may not) have changed the node's height
• So after recursive insertion in a subtree, detect height imbalance and perform a rotation to restore balance at that node

All the action is in defining the correct rotations to restore balance!

• Single rotation: The basic operation we'll use to rebalance
  • Move child of unbalanced node into parent position
  • Parent becomes the "other" child (always okay in a BST!)
  • Other subtrees move in only way BST allows.

A rotation is a constant time (\(O(1)\)) operation! Like removing from a BST, there are several different cases to handle when restoring balance to an AVL Tree. We won't go through them in detail, but we'll look at some animations to get a sense of what's going on.

There are also other kinds of balanced binary search trees. Two common ones, splay trees and red-black trees, are discussed in Bailey. AVL Trees provide the fastest searches because they are strictly balanced. Red-black trees and splay trees have more relaxed invariants, and so are faster at adding and removing nodes with fewer rotations. Java's TreeMap class uses a red-black tree.

Also called a prefix tree, a trie is a tree used for location specific keys within a set.

package student;

import java.util.HashMap;
import java.util.List;

public class Trie {
    private TrieNode overallRoot;

    private class TrieNode {
        String content;
        HashMap<Character, TrieNode> children;
        boolean isWord;

        public TrieNode(String v) {
            content = v;
            children = new HashMap<>();
        }
    }

    public Trie() {
        overallRoot = new TrieNode("");
    }

    /**
     * Insert a new word into the Trie, creating any necessary nodes.
     * @param word The word to be inserted.
     */
    public void insert(String word) {
        TrieNode current = overallRoot;

        for (char l: word.toCharArray()) {
            if (!current.children.containsKey(l)) {
                current.children.put(l, new TrieNode(Character.toString(l)));
            }
            current = current.children.get(l);
        }
        current.isWord = true;
    }

    public static void main(String[] args) {
        Trie trie = new Trie();

        trie.insert("house");
        trie.insert("home");
        trie.insert("homeland");
        trie.insert("hope");
        trie.insert("hound");
        trie.insert("hose");
    }
}

1. Give five orderings of the keys A X C S E R H that, when inserted into an initially empty BST, produce the best-case (i.e., balanced) tree.
2. Give nonrecursive implementations of get and put for a BST.
3. Write a method isBST(Node node) that takes a Node as argument and returns true if the argument node is the root of a binary search tree, false otherwise.
4. How many nodes are in a full binary tree of height \(x\)?

5. Which of the following trees are valid AVL trees?

   (A)

   

   (B)

   

   (C)

   

   (D)

   

   (E)