Red-Black Trees

Comp 122, Spring 2004

 Red-black trees: Overview
 Red-black trees are a variation of binary search
trees to ensure that the tree is balanced.
» Height is O(lg n), where n is the number of nodes.
 Operations take O(lg n) time in the worst case.

 Published by my PhD supervisor, Leo Guibas,

and Bob Sedgewick.
 Easiest of the balanced search trees, so they are
used in STL map operations…

redblack - 2 Comp 122, Spring 2004

 Hysteresis : or the value of lazyness
 Hysteresis, n. [fr. Gr. to be behind, to lag.]
a retardation of an effect when the forces acting
upon a body are changed (as if from viscosity or
internal friction); especially: a lagging in the
values of resulting magnetization in a magnetic
material (as iron) due to a changing magnetizing
force

redblack - 3 Comp 122, Spring 2004

 Red-black Tree
 Binary search tree + 1 bit per node: the attribute
color, which is either red or black.
 All other attributes of BSTs are inherited:
» key, left, right, and p.

 All empty trees (leaves) are colored black.

» We use a single sentinel, nil, for all the leaves of
red-black tree T, with color[nil] = black.
» The root’s parent is also nil[T ].

redblack - 4 Comp 122, Spring 2004

 Red-black Properties
1. Every node is either red or black.
2. The root is black.
3. Every leaf (nil) is black.
4. If a node is red, then both its children are
black.

5. For each node, all paths from the node to

descendant leaves contain the same number of
black nodes.

redblack - 5 Comp 122, Spring 2004

 Red-black Tree – Example
26 Remember: every
internal node has two
children, even though
17 41 nil leaves are not
usually shown.

30 47

38 50

nil[T]
redblack - 6 Comp 122, Spring 2004
 Height of a Red-black Tree
 Height of a node:
» h(x) = number of edges in a longest path to a leaf.
 Black-height of a node x, bh(x):
» bh(x) = number of black nodes (including nil[T ])
on the path from x to leaf, not counting x.
 Black-height of a red-black tree is the black-height
of its root.
» By Property 5, black height is well defined.

redblack - 7 Comp 122, Spring 2004

 Height of a Red-black Tree
h=4
 Example: 26 bh=2

 Height of a node:
h=3
17 h=1 41 bh=2
h(x) = # of edges in a bh=1
longest path to a leaf.
 Black-height of a node h=2
h=2 30
bh(x) = # of black nodes 47 bh=1
bh=1 h=1
on path from x to leaf, bh=1
not counting x. 38 h=1 50
bh=1
 How are they related?
» bh(x) ≤ h(x) ≤ 2 bh(x) nil[T]
redblack - 8 Comp 122, Spring 2004
 Lemma “RB Height”
Consider a node x in an RB tree: The longest
descending path from x to a leaf has length h(x),
which is at most twice the length of the shortest
descending path from x to a leaf.
Proof:
# black nodes on any path from x = bh(x) (prop 5)
 # nodes on shortest path from x, s(x). (prop 1)
But, there are no consecutive red (prop 4),
and we end with black (prop 3), so h(x) ≤ 2 bh(x).
Thus, h(x) ≤ 2 s(x). QED
redblack - 9 Comp 122, Spring 2004
 Bound on RB Tree Height
 Lemma: The subtree rooted at any node x has
 2bh(x)–1 internal nodes.
 Proof: By induction on height of x.
» Base Case: Height h(x) = 0  x is a leaf  bh(x) = 0.
Subtree has 20–1 = 0 nodes. 

» Induction Step: Height h(x) = h > 0 and bh(x) = b.

• Each child of x has height h - 1 and
black-height either b (child is red) or b - 1 (child is black).
• By ind. hyp., each child has  2bh(x)– 1–1 internal nodes.
• Subtree rooted at x has  2 (2bh(x) – 1 – 1)+1
= 2bh(x) – 1 internal nodes. (The +1 is for x itself.)

redblack - 10 Comp 122, Spring 2004

 Bound on RB Tree Height
 Lemma: The subtree rooted at any node x has
 2bh(x)–1 internal nodes.
 Lemma 13.1: A red-black tree with n internal
nodes has height at most 2 lg(n+1).
 Proof:
» By the above lemma, n  2bh – 1,
» and since bh h/2, we have n  2h/2 – 1.
»  h  2 lg(n + 1).

redblack - 11 Comp 122, Spring 2004

 Operations on RB Trees
 All operations can be performed in O(lg n) time.
 The query operations, which don’t modify the
tree, are performed in exactly the same way as
they are in BSTs.
 Insertion and Deletion are not straightforward.
Why?

redblack - 12 Comp 122, Spring 2004

 Rotations

x Left-Rotate(T, x) y

 y Right-Rotate(T, y) x 
   

redblack - 13 Comp 122, Spring 2004

 Rotations
 Rotations are the basic tree-restructuring operation for
almost all balanced search trees.
 Rotation takes a red-black-tree and a node,
 Changes pointers to change the local structure, and
 Won’t violate the binary-search-tree property.
 Left rotation and right rotation are inverses.

x Left-Rotate(T, x) y

 y Right-Rotate(T, y) x 
   
redblack - 14 Comp 122, Spring 2004
 Left Rotation – Pseudo-code
Left-Rotate (T, x)
1. y  right[x] // Set y.
2. right[x]  left[y] //Turn y’s left subtree into x’s right subtree.
3. if left[y]  nil[T ]
4. then p[left[y]]  x
5. p[y]  p[x] // Link x’s parent to y.
6. if p[x] = nil[T ]
7. then root[T ]  y x Left-Rotate(T, x) y
8. else if x = left[p[x]]
 
then left[p[x]]  y Right-Rotate(T, y)
y x
9.
10. else right[p[x]]  y    
11. left[y]  x // Put x on y’s left.
12. p[x]  y

redblack - 15 Comp 122, Spring 2004

 Rotation
 The pseudo-code for Left-Rotate assumes that
» right[x]  nil[T ], and
» root’s parent is nil[T ].
 Left Rotation on x, makes x the left child of y, and the
left subtree of y into the right subtree of x.
 Pseudocode for Right-Rotate is symmetric: exchange
left and right everywhere.
 Time: O(1) for both Left-Rotate and Right-Rotate,
since a constant number of pointers are modified.

redblack - 16 Comp 122, Spring 2004

 Reminder: Red-black Properties
1. Every node is either red or black.
2. The root is black.
3. Every leaf (nil) is black.
4. If a node is red, then both its children are
black.

5. For each node, all paths from the node to

descendant leaves contain the same number of
black nodes.

redblack - 17 Comp 122, Spring 2004

 Insertion in RB Trees
 Insertion must preserve all red-black properties.
 Should an inserted node be colored Red? Black?
 Basic steps:
» Use Tree-Insert from BST (slightly modified) to
insert a node x into T.
• Procedure RB-Insert(x).
» Color the node x red.
» Fix the modified tree by re-coloring nodes and
performing rotation to preserve RB tree property.
• Procedure RB-Insert-Fixup.

redblack - 18 Comp 122, Spring 2004

 Insertion
RB-Insert(T, z) RB-Insert(T, z) Contd.
1. y  nil[T] 14. left[z]  nil[T]
2. x  root[T] 15. right[z]  nil[T]
3. while x  nil[T] 16. color[z]  RED
4. do y  x 17. RB-Insert-Fixup (T, z)
5. if key[z] < key[x]
6. then x  left[x]
7. else x  right[x] How does it differ from the
8. p[z]  y Tree-Insert procedure of BSTs?
9. if y = nil[T] Which of the RB properties
10. then root[T]  z might be violated?
11. else if key[z] < key[y]
12. then left[y]  z Fix the violations by calling
13. else right[y]  z RB-Insert-Fixup.

redblack - 19 Comp 122, Spring 2004

 Insertion – Fixup

redblack - 20 Comp 122, Spring 2004

 Insertion – Fixup
 Problem: we may have one pair of consecutive
reds where we did the insertion.
 Solution: rotate it up the tree and away…
Three cases have to be handled…
 http://www2.latech.edu/~apaun/RBTreeDemo.htm

redblack - 21 Comp 122, Spring 2004

 Insertion – Fixup
RB-Insert-Fixup (T, z)
1. while color[p[z]] = RED
2. do if p[z] = left[p[p[z]]]
3. then y  right[p[p[z]]]
4. if color[y] = RED
5. then color[p[z]]  BLACK // Case 1
6. color[y]  BLACK // Case 1
7. color[p[p[z]]]  RED // Case 1
8. z  p[p[z]] // Case 1

redblack - 22 Comp 122, Spring 2004

 Insertion – Fixup
RB-Insert-Fixup(T, z) (Contd.)
9. else if z = right[p[z]] // color[y]  RED
10. then z  p[z] // Case 2
11. LEFT-ROTATE(T, z) // Case 2
12. color[p[z]]  BLACK // Case 3
13. color[p[p[z]]]  RED // Case 3
14. RIGHT-ROTATE(T, p[p[z]]) // Case 3
15. else (if p[z] = right[p[p[z]]])(same as 10-14
16. with “right” and “left” exchanged)
17. color[root[T ]]  BLACK

redblack - 23 Comp 122, Spring 2004

 Correctness
Loop invariant:
 At the start of each iteration of the while loop,
» z is red.
» If p[z] is the root, then p[z] is black.
» There is at most one red-black violation:
• Property 2: z is a red root, or
• Property 4: z and p[z] are both red.

redblack - 24 Comp 122, Spring 2004

 Correctness – Contd.
 Initialization: 
 Termination: The loop terminates only if p[z] is black.
Hence, property 4 is OK.
The last line ensures property 2 always holds.
 Maintenance: We drop out when z is the root (since
then p[z] is sentinel nil[T ], which is black). When we
start the loop body, the only violation is of property 4.
» There are 6 cases, 3 of which are symmetric to the other 3.
We consider cases in which p[z] is a left child.
» Let y be z’s uncle (p[z]’s sibling).

redblack - 25 Comp 122, Spring 2004

 p[p[z]]
Case 1 – uncle y is red
new z
C C
p[z]
y
A D A D
z
     
B B
z is a right child here.
Similar steps if z is a left child.
  

 p[p[z]] (z’s grandparent) must be black, since z and p[z] are both red and there
are no other violations of property 4.
 Make p[z] and y black  now z and p[z] are not both red. But property 5
might now be violated.
 Make p[p[z]] red  restores property 5.
 The next iteration has p[p[z]] as the new z (i.e., z moves up 2 levels).
redblack - 26 Comp 122, Spring 2004
 Case 2 – y is black, z is a right child
C C
p[z] p[z]
A  y B  y
z
 z A 
B

   

 Left rotate around p[z], p[z] and z switch roles  now z is a left
child, and both z and p[z] are red.
 Takes us immediately to case 3.

redblack - 27 Comp 122, Spring 2004

 Case 3 – y is black, z is a left child
C B
p[z]
B  y A C

z
   
A 

 
 Make p[z] black and p[p[z]] red.
 Then right rotate on p[p[z]]. Ensures property 4 is maintained.
 No longer have 2 reds in a row.
 p[z] is now black  no more iterations.

redblack - 28 Comp 122, Spring 2004

 Algorithm Analysis
 O(lg n) time to get through RB-Insert up to the
call of RB-Insert-Fixup.
 Within RB-Insert-Fixup:
» Each iteration takes O(1) time.
» Each iteration but the last moves z up 2 levels.
» O(lg n) levels  O(lg n) time.
» Thus, insertion in a red-black tree takes O(lg n) time.
» Note: there are at most 2 rotations overall.

redblack - 29 Comp 122, Spring 2004

 Deletion
 Deletion, like insertion, should preserve all the
RB properties.
 The properties that may be violated depends on
the color of the deleted node.
» Red – OK. Why?
» Black?
 Steps:
» Do regular BST deletion.
» Fix any violations of RB properties that may result.

redblack - 30 Comp 122, Spring 2004

 Deletion
RB-Delete(T, z)
1. if left[z] = nil[T] or right[z] = nil[T]
2. then y  z
3. else y  TREE-SUCCESSOR(z)
4. if left[y] = nil[T ]
5. then x  left[y]
6. else x  right[y]
7. p[x]  p[y] // Do this, even if x is nil[T]

redblack - 31 Comp 122, Spring 2004

 Deletion
RB-Delete (T, z) (Contd.)
8. if p[y] = nil[T ]
9. then root[T ]  x
10. else if y = left[p[y]]
11. then left[p[y]]  x
12. else right[p[y]]  x
13. if y = z
14. then key[z]  key[y] The node passed to
15. copy y’s satellite data into z the fixup routine is
16. if color[y] = BLACK the lone child of the
17. then RB-Delete-Fixup(T, x) spliced up node, or
18. return y the sentinel.

redblack - 32 Comp 122, Spring 2004

 RB Properties Violation
 If y is black, we could have violations of red-
black properties:
» Prop. 1. OK.
» Prop. 2. If y is the root and x is red, then the root has
become red.
» Prop. 3. OK.
» Prop. 4. Violation if p[y] and x are both red.
» Prop. 5. Any path containing y now has 1 fewer
black node.

redblack - 33 Comp 122, Spring 2004

 RB Properties Violation
 Prop. 5. Any path containing y now has 1 fewer black
node.
» Correct by giving x an “extra black.”
» Add 1 to count of black nodes on paths containing x.
» Now property 5 is OK, but property 1 is not.
» x is either doubly black (if color[x] = BLACK) or red &
black (if color[x] = RED).
» The attribute color[x] is still either RED or BLACK. No new
values for color attribute.
» In other words, the extra blackness on a node is by virtue of x
pointing to the node.
 Remove the violations by calling RB-Delete-Fixup.

redblack - 34 Comp 122, Spring 2004

 Deletion – Fixup
RB-Delete-Fixup(T, x)
1. while x  root[T ] and color[x] = BLACK
2. do if x = left[p[x]]
3. then w  right[p[x]]
4. if color[w] = RED
5. then color[w]  BLACK // Case 1
6. color[p[x]]  RED // Case 1
7. LEFT-ROTATE(T, p[x]) // Case 1
8. w  right[p[x]] // Case 1

redblack - 35 Comp 122, Spring 2004

 RB-Delete-Fixup(T, x) (Contd.)
/* x is still left[p[x]] */
9. if color[left[w]] = BLACK and color[right[w]] = BLACK
10. then color[w]  RED // Case 2
11. x  p[x] // Case 2
12. else if color[right[w]] = BLACK
13. then color[left[w]]  BLACK // Case 3
14. color[w]  RED // Case 3
15. RIGHT-ROTATE(T,w) // Case 3
16. w  right[p[x]] // Case 3
17. color[w]  color[p[x]] // Case 4
18. color[p[x]]  BLACK // Case 4
19. color[right[w]]  BLACK // Case 4
20. LEFT-ROTATE(T, p[x]) // Case 4
21. x  root[T ] // Case 4
22. else (same as then clause with “right” and “left” exchanged)
23. color[x]  BLACK
redblack - 36 Comp 122, Spring 2004
 Deletion – Fixup
 Idea: Move the extra black up the tree until x points to
a red & black node  turn it into a black node,
 x points to the root  just remove the extra black, or
 We can do certain rotations and recolorings and finish.
 Within the while loop:
» x always points to a nonroot doubly black node.
» w is x’s sibling.
» w cannot be nil[T ], since that would violate property 5 at
p[x].
 8 cases in all, 4 of which are symmetric to the other.

redblack - 37 Comp 122, Spring 2004

 Case 1 – w is red
p[x]
B D
x w
A D B E
  x A new w C  
C E
   
   
 w must have black children.
 Make w black and p[x] red (because w is red p[x] couldn’t have
been red).
 Then left rotate on p[x].
 New sibling of x was a child of w before rotation  must be
black.
 Go immediately to case 2, 3, or 4.

redblack - 38 Comp 122, Spring 2004

 Case 2 – w is black, both w’s children
p[x] c are black new x c
B B
x w
A D A D
   
C E C E
       

 Take 1 black off x ( singly black) and off w ( red).

 Move that black to p[x].
 Do the next iteration with p[x] as the new x.
 If entered this case from case 1, then p[x] was red  new x is
red & black  color attribute of new x is RED  loop
terminates. Then new x is made black in the last line.
redblack - 39 Comp 122, Spring 2004
 Case 3 – w is black, w’s left child is red,
w’s right child is black
c
B B c
x w
x new w
A D A C
   

D
C E
 E
   

 
 Make w red and w’s left child black.
 Then right rotate on w.
 New sibling w of x is black with a red right child  case 4.

redblack - 40 Comp 122, Spring 2004

 Case 4 – w is black, w’s right child is red
c
B D
x w
A D B E
  x A C  
c’
C E
   
   

 Make w be p[x]’s color (c).

 Make p[x] black and w’s right child black.
 Then left rotate on p[x].
 Remove the extra black on x ( x is now singly black) without
violating any red-black properties.
 All done. Setting x to root causes the loop to terminate.
redblack - 41 Comp 122, Spring 2004
 Analysis
 O(lg n) time to get through RB-Delete up to the
call of RB-Delete-Fixup.
 Within RB-Delete-Fixup:
» Case 2 is the only case in which more iterations
occur.
• x moves up 1 level.
• Hence, O(lg n) iterations.
» Each of cases 1, 3, and 4 has 1 rotation   3
rotations in all.
» Hence, O(lg n) time.

redblack - 42 Comp 122, Spring 2004

 Hysteresis : or the value of lazyness
 The red nodes give us some slack – we don’t
have to keep the tree perfectly balanced.
 The colors make the analysis and code much
easier than some other types of balanced trees.
 Still, these aren’t free – balancing costs some
time on insertion and deletion.

redblack - 43 Comp 122, Spring 2004