Scribd
Upload
19 views

CS 332: Algorithms: Red-Black Trees

This document summarizes red-black trees, a type of self-balancing binary search tree. It discusses: 1) The properties of red-black trees, including that every node is red or black, leaves are black, and the paths from any node to leaves contain the same number of black nodes. 2) How to prove that the height of a red-black tree is O(log n) by showing the minimum black height is at least h/2 for a node of height h. 3) That common BST operations like search, minimum, maximum take O(log n) time on red-black trees due to the balanced tree structure. Insert and delete also take O(log n) time

Uploaded by

Anonymous niE5VQOH
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
19 views

CS 332: Algorithms: Red-Black Trees

This document summarizes red-black trees, a type of self-balancing binary search tree. It discusses: 1) The properties of red-black trees, including that every node is red or black, leaves are black, and the paths from any node to leaves contain the same number of black nodes. 2) How to prove that the height of a red-black tree is O(log n) by showing the minimum black height is at least h/2 for a node of height h. 3) That common BST operations like search, minimum, maximum take O(log n) time on red-black trees due to the balanced tree structure. Insert and delete also take O(log n) time

Uploaded by

Anonymous niE5VQOH
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 20

CS 332: Algorithms

Red-Black Trees

Review: Binary Search Trees


Binary Search Trees (BSTs) are an important

data structure for dynamic sets


In addition to satellite data, eleements have:
key: an identifying field inducing a total ordering
left: pointer to a left child (may be NULL)
right: pointer to a right child (may be NULL)
p: pointer to a parent node (NULL for root)

Review: Binary Search Trees


BST property:

key[left(x)] key[x] key[right(x)]


Example:
F
B
A

H
D

Review: Inorder Tree Walk


An inorder walk prints the set in sorted order:

TreeWalk(x)
TreeWalk(left[x]);
print(x);
TreeWalk(right[x]);
Easy to show by induction on the BST property
Preorder tree walk: print root, then left, then right
Postorder tree walk: print left, then right, then root

Review: BST Search


TreeSearch(x, k)
if (x = NULL or k = key[x])
return x;
if (k < key[x])
return TreeSearch(left[x], k);
else
return TreeSearch(right[x], k);

Review: BST Search (Iterative)


IterativeTreeSearch(x, k)
while (x != NULL and
if (k < key[x])
x = left[x];
else
x = right[x];
return x;

k != key[x])

Review: BST Insert


Adds an element x to the tree so that the binary

search tree property continues to hold


The basic algorithm
Like the search procedure above
Insert x in place of NULL
Use a trailing pointer to keep track of where you

came from (like inserting into singly linked list)


Like search, takes time O(h), h = tree height

Review: Sorting With BSTs


Basic algorithm:
Insert elements of unsorted array from 1..n
Do an inorder tree walk to print in sorted order

Running time:
Best case: (n lg n) (its a comparison sort)
Worst case: O(n2)
Average case: O(n lg n) (its a quicksort!)

Review: Sorting With BSTs


Average case analysis
Its a form of quicksort!

for i=1 to n
TreeInsert(A[i]);
InorderTreeWalk(root);

3 1 8 2 6 7 5
1 2

8 6 7 5
2

6 7 5
5

6
5

Review: More BST Operations


Minimum:
Find leftmost node in tree

Successor:
x has a right subtree: successor is minimum node in right

subtree
x has no right subtree: successor is first ancestor of x whose
left child is also ancestor of x
Intuition: As long as you move to the left up the tree, youre

visiting smaller nodes.

Predecessor: similar to successor

Review: More BST Operations


Delete:
x has no children:
Remove x
x has one child:
Splice out x

F
B

H
D

x has two children:


C
Swap x with successor
Perform case 1 or 2 to delete it

K
Example: delete K
or H or B

Red-Black Trees
Red-black trees:
Binary search trees augmented with node color
Operations designed to guarantee that the height

h = O(lg n)
First: describe the properties of red-black trees
Then: prove that these guarantee h = O(lg n)
Finally: describe operations on red-black trees

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

Red-Black Trees
Put example on board and verify properties:

1.
2.
3.
4.

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
5. The root is always black
black-height: # black nodes on path to leaf
Label example with h and bh values

Height of Red-Black Trees


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)
How do you suppose well prove this?

RB Trees: Proving Height Bound


Prove: n-node RB tree has height h 2 lg(n+1)
Claim: A subtree rooted at a node x contains at

least 2bh(x) - 1 internal nodes


Proof by induction on height h
Base step: x has height 0 (i.e., NULL leaf node)
What is bh(x)?

RB Trees: Proving Height Bound


Prove: n-node RB tree has height h 2 lg(n+1)
Claim: A subtree rooted at a node x contains at

least 2bh(x) - 1 internal nodes


Proof by induction on height h
Base step: x has height 0 (i.e., NULL leaf node)
What is bh(x)?
A: 0
Sosubtree contains 2bh(x) - 1

= 20 - 1
= 0 internal nodes (TRUE)

RB Trees: Proving Height Bound


Inductive proof that subtree at node x contains at

least 2bh(x) - 1 internal nodes


Inductive step: x has positive height and 2 children
Each child has black-height of bh(x) or bh(x)-1 (Why?)
The height of a child = (height of x) - 1
So the subtrees rooted at each child contain at least

2bh(x) - 1 - 1 internal nodes


Thus subtree at x contains
(2bh(x) - 1 - 1) + (2bh(x) - 1 - 1) + 1
= 22bh(x)-1 - 1 = 2bh(x) - 1 nodes

RB Trees: 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)

(Why?)
(Why?)
(Why?)
(Why?)

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

You might also like