CS 332: Algorithms
Red-Black Trees
Review: Red-Black Trees
Red-black trees:
Binary search trees augmented with node color
Operations designed to guarantee that the height
h = O(lg n)
We described the properties of red-black trees
We proved that these guarantee h = O(lg n)
Next: describe operations on red-black trees
Review: Red-Black Properties
The red-black properties:
1. Every node is either red or black
2. Every leaf (NULL pointer) is black
Note: this means every real node has 2 children
3. If a node is red, both children are black
Note: cant have 2 consecutive reds on a path
4. Every path from node to descendent leaf contains
the same number of black nodes
5. The root is always black
Review: Black-Height
black-height: # black nodes on path to leaf
What is the minimum black-height of a node
with height h?
A: a height-h node has black-height h/2
Theorem: A red-black tree with n internal
nodes has height h 2 lg(n + 1)
Proved by (what else?) induction
Review: Proving Height Bound
Thus at the root of the red-black tree:
n 2bh(root) - 1
n 2h/2 - 1
lg(n+1) h/2
h 2 lg(n + 1)
Thus h = O(lg n)
RB Trees: Worst-Case Time
So weve proved that a red-black tree has
O(lg n) height
Corollary: These operations take O(lg n) time:
Minimum(), Maximum()
Successor(), Predecessor()
Search()
Insert() and Delete():
Will also take O(lg n) time
But will need special care since they modify tree
Red-Black Trees: An Example
Color this tree:
7
5
9
12
12
Red-black properties:
1.
Every node is either red or black
2.
Every leaf (NULL pointer) is black
3.
If a node is red, both children are black
4.
Every path from node to descendent leaf
contains the same number of black nodes
5.
The root is always black
Red-Black Trees:
The Problem With Insertion
Insert 8
Where does it go?
7
5
9
12
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
Red-Black Trees:
The Problem With Insertion
Insert 8
Where does it go?
What color
7
5
should it be?
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
9
8
12
Red-Black Trees:
The Problem With Insertion
Insert 8
Where does it go?
What color
7
5
should it be?
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
9
8
12
Red-Black Trees:
The Problem With Insertion
Insert 11
Where does it go?
7
5
9
8
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
12
Red-Black Trees:
The Problem With Insertion
Insert 11
Where does it go?
What color?
7
5
9
8
12
11
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
Red-Black Trees:
The Problem With Insertion
Insert 11
Where does it go?
What color?
7
5
Cant be red! (#3)
9
8
12
11
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
Red-Black Trees:
The Problem With Insertion
Insert 11
Where does it go?
What color?
7
5
Cant be red! (#3)
Cant be black! (#4)
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
9
8
12
11
Red-Black Trees:
The Problem With Insertion
Insert 11
Where does it go?
What color?
7
5
Solution:
recolor the tree
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
9
8
12
11
Red-Black Trees:
The Problem With Insertion
Insert 10
Where does it go?
7
5
9
8
12
11
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
Red-Black Trees:
The Problem With Insertion
Insert 10
Where does it go?
What color?
7
5
9
8
12
11
1.
2.
3.
4.
5.
Every node is either red or black
Every leaf (NULL pointer) is black
If a node is red, both children are black
Every path from node to descendent leaf
contains the same number of black nodes
The root is always black
10
Red-Black Trees:
The Problem With Insertion
Insert 10
Where does it go?
What color?
7
5
A: no color! Tree
is too imbalanced
Must change tree structure
to allow recoloring
Goal: restructure tree in
O(lg n) time
9
8
12
11
10
RB Trees: Rotation
Our basic operation for changing tree structure is called
rotation:
y
x
rightRotate(y)
leftRotate(x)
ADoes rotation
B
B
preserve inorder key ordering?
What would the code for rightRotate() actually
do?
RB Trees: Rotation
y
x
A
rightRotate(y)
y
B
Answer: A lot of pointer manipulation
x keeps its left child
y keeps its right child
xs right child becomes ys left child
xs and ys parents change
What is the running time?
Rotation Example
Rotate left about 9:
7
5
9
8
12
11
Rotation Example
Rotate left about 9:
7
5
12
9
8
11
Red-Black Trees: Insertion
Insertion: the basic idea
Insert x into tree, color x red
Only r-b property 3 might be violated (if p[x] red)
If so, move violation up tree until a place is found
where it can be fixed
Total time will be O(lg n)
rbInsert(x)
treeInsert(x);
x->color = RED;
// Move violation of #3 up tree, maintaining #4 as invariant:
while (x!=root && x->p->color == RED)
if (x->p == x->p->p->left)
y = x->p->p->right;
if (y->color == RED)
x->p->color = BLACK;
y->color = BLACK;
x->p->p->color = RED;
x = x->p->p;
else
// y->color == BLACK
if (x == x->p->right)
x = x->p;
leftRotate(x);
x->p->color = BLACK;
x->p->p->color = RED;
rightRotate(x->p->p);
else
// x->p == x->p->p->right
(same as above, but with
right & left exchanged)
Case 1
Case 2
Case 3
rbInsert(x)
treeInsert(x);
x->color = RED;
// Move violation of #3 up tree, maintaining #4 as invariant:
while (x!=root && x->p->color == RED)
if (x->p == x->p->p->left)
y = x->p->p->right;
if (y->color == RED)
x->p->color = BLACK;
y->color = BLACK;
x->p->p->color = RED;
x = x->p->p;
else
// y->color == BLACK
if (x == x->p->right)
x = x->p;
leftRotate(x);
x->p->color = BLACK;
x->p->p->color = RED;
rightRotate(x->p->p);
else
// x->p == x->p->p->right
(same as above, but with
right & left exchanged)
Case 1: uncle is RED
Case 2
Case 3
RB Insert: Case 1
Case 1: uncle is red
if (y->color == RED)
x->p->color = BLACK;
y->color = BLACK;
x->p->p->color = RED;
x = x->p->p;
In figures below, all s are
equal-black-height subtrees
case 1
D y
B x
C new x
D
B
Change colors of some nodes, preserving #4: all downward paths have equal b.h.
The while loop now continues with xs grandparent as the new x
RB Insert: Case 1
Case 1: uncle is red
if (y->color == RED)
x->p->color = BLACK;
y->color = BLACK;
x->p->p->color = RED;
x = x->p->p;
In figures below, all s are
equal-black-height subtrees
case 1
A
B x
C new x
D y
B x
Same action whether x is a left or a right child
RB Insert: Case 2
if (x == x->p->right)
x = x->p;
leftRotate(x);
// continue with case 3 code
Case 2:
Uncle is black
Node x is a right child
Transform to case 3 via a left-
rotation
B x
case 2
A x
Transform case 2 into case 3 (x is left child) with a left rotation
This preserves property 4: all downward paths contain same number of black nodes
RB Insert: Case 3
Case 3:
Uncle is black
Node x is a left child
x->p->color = BLACK;
x->p->p->color = RED;
rightRotate(x->p->p);
Change colors; rotate right
C
B
A x
case 3
Perform some color changes and do a right rotation
Again, preserves property 4: all downward paths contain same number of black nodes
RB Insert: Cases 4-6
Cases 1-3 hold if xs parent is a left child
If xs parent is a right child, cases 4-6 are
symmetric (swap left for right)
Red-Black Trees: Deletion
And you thought insertion was tricky
We will not cover RB delete in class
You should read section 14.4 on your own
Read for the overall picture, not the details
The End
Coming up:
Skip lists
Hash tables
