Introduction

Last week, we were describing how binary search trees (BSTs) could be used as an implementation of the operations of a dynamic set.
Each operation we described, namely, MAX, MIN, PREDECESSOR, SUCCESSOR, SEARCH, INSERT, DELETE, was `Theta(h)` time in the worst case, where `h` is the height of the BST.
Unfortunately, the height of a BST can be `Theta(n)` where `n` is the number of items in the tree in the worst case.
We next look at a model that could be used to say what happens in the "average case", we state the result, but don't give the actual proof.
We then look at ways to modify the basic BST to guarantee that logarithmic height.

How to Randomly Build a Tree

Imagine we build a BST using the insertion operation.
Suppose we have `n` items to insert: `a_1, ..., a_n`.
We imagine that some randomly permutes these `n` items and presents them to us one-by-one and we insert them into a BST.
Let `pi` be a permutation of these `n` items. We can define a probability distribution `Pr: pi mapsto 1/(n!)` which treats each permutation as equally likely.
A given permutation `pi`, determines the tree, `T_(pi)` that will be constructed and the tree height of that tree, `h(T_(pi))`. Let `Pi` be the space of all permutations of `n`. So the map `H: pi mapsto h(T_pi)` is a random variable on this space.
We would like to compute `E(H)`.
The book shows the following result whose proof we'll skip:
Theorem. `E(H)` is `O(log n)`.

Self-Balancing Trees

From the book's results, we know the average run times of the dynamic set operations on BST will be `O(log n)`.
We would like to be able to modify the basic data structure so that we have this behavior as well in the worst case.
There are several ways this can be done. Some other books do this using a notion called an AVL tree or a 2-3-4 tree.
Our book uses a data structure called a Red-Black tree.
Two ways we might think of measuring how balanced a tree is would be: (1) Comparing the heights of the left and right sub-trees and checking that they are relatively close to each. (2) Check that most nodes are "full", have two children of roughly equal number of nodes (full usually means has two children or none (i.e., not just one child)).

Red-Black Trees

Definition. A red-black tree is a binary search tree where each node also has color which can be either red or black and where the nodes of the tree satisfy the following red-black properties:

Every node is either red or black.
The root is black.
Every leaf (NIL) is black.
If a node is red, then both its children are black. (a little like fullness)
For each node, all simple paths from the node to descendant leaves contains the same number of black nodes. (a little like comparing left and right heights)

Example Red-Black Tree

We call the number of black nodes on any simple path from, but not including, node `x` done to a leaf the black-height of the node, denoted `bh(x)`.
By property 5 of red-black trees, the notion of black-height is well defined.
The numbers next to each node above indicate their black height.
We will assume we have some way to find the parent of a NIL node even though it is NIL, This can be done using a trailing pointer or a sentinel.
We will mainly be interested in the internal nodes of a Red-Black Tree.

Quiz (Sec 5)

Which of the following statements is true?

The multiple array representation of an object uses less memory than the single array representation of an object.
The TRANSPLANT procedure we described last day for binary trees was `Omega(log n)`.
The TREE-INSERT procedure we described last day made use of a trailing pointer.

Quiz (Sec 6)

Which of the following statements is true?

A free space list as described in the book is a singly linked list.
TREE-SUCCESSOR(x) will always return a node in a subtree of `x`.
In the worst case, TREE-DELETE(T,z) is a `O(log n)` algorithm.

Height of Red-Black Trees

The folowing lemma shows that red-black trees make good search trees:

Lemma. A red-black tree with `n` internal nodes has height at most `2log(n+1)`.

Proof. We claim first that the subtree rooted at any node `x` contains at least `2^(bh(x)) - 1` internal nodes. We prove this claim by induction on the height of `x`. If `x` has height `0`, then `x` must be a leaf, and the subtree rooted at `x` contains `2^(bh(x)) - 1 = 2^0 - 1 = 0` internal nodes. For the induction step, let `x` be a node of positive height and suppose it is an internal node with two children. A child will have black-height `bh(x)` if the child is red and `bh(x) - 1` if the child is black. Since the child of `x` has less height than `x`, we can apply the induction hypothesis to conclude that each child has at least `2^(bh(x) - 1) -1` internal nodes. So the subtree root at `x` had at least
`(2^(bh(x) -1) - 1) + (2^(bh(x) -1 ) - 1) + 1 = (2^(bh(x)) - 1)` internal nodes. So the induction hypothesis holds in this case.

To complete the proof of the lemma, let `h` be the height of the tree. By Property 4, at least half the nodes on any simple path from the root to a leaf, not including the root must be black. So the black height must be at least `h/2`. So `n ge 2^(h/2) -1`. Moving `1` to the right hand side and taking logarithms on both sides yields
`log(n+1) ge h/2` or `h le 2log(n + 1)`.

Rotations

So run on a red-black tree, SEARCH, MINIMUM, MAXIMUM, SUCCESSOR, and PREDECESSOR will be `O(log n)`. We can run these as often as we want still get this run time bound as these operations don't modify the tree.
Similarly, run on a red-black tree, TREE-INSERT and TREE-DELETE will take `O(log n)` time.
Unfortunately, since these operations modify the tree, the resulting tree may no longer be a red-black tree.
We next discuss how to modify the resulting tree to make it red black again.
The key concept we will use is the idea of a rotation.
The above diagram illustrates how we modify the node structure of a tree when we do a left rotation about x, or a right rotation about `y`.
Notice rotations preserve the binary search tree property.

Red-Black Trees

Outline

Introduction

How to Randomly Build a Tree

Self-Balancing Trees

Red-Black Trees

Example Red-Black Tree

Quiz (Sec 5)

Quiz (Sec 6)

Height of Red-Black Trees

Rotations