RB Trees

CMPS 2200 – Fall 2017
Red-black trees
Carola Wenk
Slides courtesy of Charles Leiserson with changes by Carola Wenk
9/13/17 CMPS 2200 Intro. to Algorithms 1

Dynamic Set
A dynamic set, or dictionary, is a data
structure which supports operations
• Insert
7
• Delete 3 18
• Find 10 22
8 15
12 17
Using balanced binary search trees we can

implement a dictionary data structure such that
each operation takes O(log n) time.
Search Trees
• A binary search tree is a binary tree. Each node stores a
key. The tree fulfills the binary search tree property:
For every node x holds:
• y  x , for all y in the subtree left of x
x
• x < y, for all y in the subtree right of x
7
x x
3 18
10 22
8 15
12 17

Search Trees 7
3 18
Different variants of search trees: 1 12 10 22
8 15
• Balanced search trees (guarantee
height of O(log n) for n elements) 12 17
10 25
• k-ary search trees (such as B-trees, 6 12 15 21 30 45
2-3-4-trees) 2 7 8 11 14 20 23 24 27 40 50
17
• Search trees that store keys only 8 42
in leaves, and store copies of 1 14 35 43
keys as split-values in 1 6 12 17 26 41 43 59
internal nodes 6 8 12 14 26 35 41 42 59 61

Balanced search trees
Balanced search tree: A search-tree data
structure for which a height of O(log n) is
guaranteed when implementing a dynamic
set of n items.
• AVL trees
• 2-3 trees
Examples: • 2-3-4 trees
• B-trees
• Red-black trees

Red-black trees
This data structure requires an extra one-
bit color field in each node.
Red-black properties:
1. Every node is either red or black.
2. The root is black.
3. The leaves (null’s) are black.
4. If a node is red, then both its children are black.
5. All simple paths from any node x, excluding x,
to a descendant leaf have the same number of
black nodes = black-height(x).
Example of a red-black tree
7
3 18
null null
10 22 h=4
null
8 11 26
null null null null null null

7
3 18
null null
10 22 h=4
null
8 11 26
2., 3. The root and leaves (null’s) are black.

7
3 18
null null
10 22 h=4
null
8 11 26
4. If a node is red, then both its children are

black.
7 bh = 2
3 18 bh = 2
null null
bh = 1 10 22 h=4
null
bh = 1 8 11 26
bh = 0
5. All simple paths from any node x, excluding
x, to a descendant leaf have the same
number of black nodes = black-height(x).
Height of a red-black tree
Theorem. A red-black tree with n keys has height
h  2 log(n + 1).
Proof.
INTUITION: T
• Merge red nodes
into their black
parents.

h  2 log(n + 1).
Proof.
INTUITION: T
• Merge red nodes
into their black
parents.

h  2 log(n + 1).
Proof.
INTUITION: T
• Merge red nodes
into their black
parents.

h  2 log(n + 1).
Proof.
INTUITION: T
• Merge red nodes
into their black
parents.

h  2 log(n + 1).
Proof.
INTUITION: T’
• Merge red nodes
into their black
parents.

h  2 log(n + 1).
Proof.
INTUITION: T’
• Merge red nodes h
into their black
parents.
• This process produces a tree in which each node
has 2, 3, or 4 children.
• The 2-3-4 tree has uniform depth h of leaves.
Proof (continued)
• We have h  h/2,
since at most half T
the vertices on
any path are red.
• # leaves in T = # leaves in T’ h
• # leaves in T = n+1 (fact about
binary trees with exactly 2
children per internal node)
• # leaves in T’  2h’(fact about T’
binary trees; T’ can only have
more) h
 n + 1  2h'
 log(n + 1)  h'  h/2
 h  2 log(n + 1).
Query operations
Corollary. The queries SEARCH, MIN,
MAX, SUCCESSOR, and PREDECESSOR
all run in O(log n) time on a red-black
tree with n nodes.
7
3 18
10 22
8 11 26

Modifying operations
The operations INSERT and DELETE cause
modifications to the red-black tree:
1. the operation itself,
2. color changes,
3. restructuring the links of the tree
via “rotations”.

Rotations
B RIGHT-ROTATE(B) A
A LEFT-ROTATE(A) B
 
   
• Rotations maintain the inorder ordering of keys:
a  , b  , c   a  A  b  B  c.
• Rotations maintain the binary search tree property
 Can be applied to any BST, not just red-black trees
• A rotation can be performed in O(1) time.
B RIGHT-ROTATE(B) A
Rotation Example A

LEFT-ROTATE(A)

B
   
31 RIGHT-ROTATE(20) 31
9 41 9 41
6 20 39 42 6 16 39 42
2 8 16 22 2 8 15 20
In-order(v){
15 17 11 17 22
if v==null return;
In-order(v.left);
11 print(v.key+” ”);
In-order(v.right);
}
In-order traversal: In-order traversal:
2 6 8 9 11 15 16 17 20 22 31 39 41 42 2 6 8 9 11 15 16 17 20 22 31 39 41 42
 Maintains sorted order of keys, and can reduce height

Red-black trees
This data structure requires an extra one-
bit color field in each node.
Red-black properties:
2. The root is black.
3. The leaves (null’s) are black.
4. If a node is red, then both its children are black.
5. All simple paths from any node x, excluding x,
to a descendant leaf have the same number of
black nodes = black-height(x).
Insertion into a red-black tree
IDEA: Insert x in tree. Color x red. Only red-
black property 4 might be violated. Move the
violation up the tree by recoloring until it can
be fixed with rotations and recoloring.
7
Example:
3 18
• Insert x =15.
10 22
8 11 26
15

7
Example:
3 18
• Insert x =15.
• Recolor, moving the 10 22
violation up the tree. 8 11 26
15

7
Example:
3 18
• Insert x =15.
15

7
Example:
3 18
• Insert x =15.
• RIGHT-ROTATE(18).
15

7
Example:
3 10
• Insert x =15.
violation up the tree. 11 22
• RIGHT-ROTATE(18). 15 26

7
Example:
3 10
• Insert x =15.
• RIGHT-ROTATE(18). 15 26
• LEFT-ROTATE(7)
10
Example:
• Insert x =15. 7 18
• Recolor, moving the 3 8 11 22
• LEFT-ROTATE(7)
10
Example:
• Insert x =15. 7 18
• LEFT-ROTATE(7) and recolor.
10
Example:
• Insert x =15. 7 18
• LEFT-ROTATE(7) and recolor.
Pseudocode
RB-INSERT(T, x)
TREE-INSERT(T, x)
color[x]  RED ⊳ only RB property 4 can be violated
while x  root[T] and color[p[x]] = RED
do if p[x] = left[p[p[x]]
then y  right[p[p[x]] ⊳ y = aunt/uncle of x
if color[y] = RED
then Case 1
else if x = right[p[x]]
then Case 2 ⊳ Case 2 falls into Case 3
Case 3
else “then” clause with “left” and “right” swapped
color[root[T]]  BLACK
Graphical notation
Let denote a subtree with a black root.
All ’s have the same black-height.

Case 1
Recolor Continue
C C new x
A D y A D
x B B
(Or, A’s children are swapped.) Push C’s black onto A

p[x] = left[p[p[x]]
and D, and recurse,
since C’s parent may be
y  right[p[p[x]] red.
color[y] = RED
Case 2
C LEFT-ROTATE(A) C
y y
A B
x B x A
p[x] = left[p[p[x]]
y  right[p[p[x]]
Transform to Case 3.
color[y] = BLACK
x = right[p[x]]
Case 3
C
RIGHT-ROTATE(C)
y (and recolor) B
B
A C
x A
Done! No more
p[x] = left[p[p[x]] violations of RB
y  right[p[p[x]] property 4 are
color[y] = BLACK possible.
x = left[p[x]]
Analysis
• Go up the tree performing Case 1, which only

recolors nodes.
• If Case 2 or Case 3 occurs, perform 1 or 2
rotations, and terminate.
Running time: O(log n) with O(1) rotations.
RB-DELETE — same asymptotic running time
and number of rotations as RB-INSERT.

Pseudocode (part II)
else “then” clause with “left” and “right” swapped
⊳ p[x] = right[p[p[x]]
then y  left[p[p[x]] ⊳ y = aunt/uncle of x
if color[y] = RED
then Case 1’
else if x = left[p[x]]
then Case 2’ ⊳ Case 2’ falls into Case 3’
Case 3’
color[root[T]]  BLACK

Case 1’
Recolor Continue
C C new x
D y A D y A
x B x B
(Or, A’s children are swapped.) Push C’s black onto A

p[x] = right[p[p[x]]
and D, and recurse,
since C’s parent may be
y  left[p[p[x]] red.
color[y] = RED
Case 2’
C RIGHT-ROTATE(A) C
y A y B
x
x B
A
p[x] = right[p[p[x]]
y  left[p[p[x]]
Transform to Case 3’.
color[y] = BLACK
x = left[p[x]]
Case 3’
LEFT-ROTATE(C)
C
x (and recolor) B
y B
C A
Done! No more
p[x] = right[p[p[x]] violations of RB
y  left[p[p[x]] property 4 are
color[y] = BLACK possible.
x = right[p[x]]

RB Trees

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

RB Trees

Uploaded by

Copyright:

Available Formats

CMPS 2200 – Fall 2017

Slides courtesy of Charles Leiserson with changes by Carola Wenk

9/13/17 CMPS 2200 Intro. to Algorithms 1

Using balanced binary search trees we can

9/13/17 CMPS 2200 Intro. to Algorithms 3

Different variants of search trees: 1 12 10 22

• k-ary search trees (such as B-trees, 6 12 15 21 30 45

• Search trees that store keys only 8 42

in leaves, and store copies of 1 14 35 43

9/13/17 CMPS 2200 Intro. to Algorithms 4

9/13/17 CMPS 2200 Intro. to Algorithms 5

1. Every node is either red or black.

2., 3. The root and leaves (null’s) are black.

4. If a node is red, then both its children are

9/13/17 CMPS 2200 Intro. to Algorithms 11

9/13/17 CMPS 2200 Intro. to Algorithms 12

9/13/17 CMPS 2200 Intro. to Algorithms 13

9/13/17 CMPS 2200 Intro. to Algorithms 14

9/13/17 CMPS 2200 Intro. to Algorithms 15

9/13/17 CMPS 2200 Intro. to Algorithms 18

9/13/17 CMPS 2200 Intro. to Algorithms 19

 Maintains sorted order of keys, and can reduce height

9/13/17 CMPS 2200 Intro. to Algorithms 23

9/13/17 CMPS 2200 Intro. to Algorithms 24

9/13/17 CMPS 2200 Intro. to Algorithms 25

9/13/17 CMPS 2200 Intro. to Algorithms 26

9/13/17 CMPS 2200 Intro. to Algorithms 27

Let denote a subtree with a black root.

All ’s have the same black-height.

9/13/17 CMPS 2200 Intro. to Algorithms 33

(Or, A’s children are swapped.) Push C’s black onto A

• Go up the tree performing Case 1, which only

9/13/17 CMPS 2200 Intro. to Algorithms 37

9/13/17 CMPS 2200 Intro. to Algorithms 38

(Or, A’s children are swapped.) Push C’s black onto A

You might also like