Balanced Search Trees

3.4 – 3.7

Team names
Majed Suhaim
Ahmed Sulaiman M Alharbi
 RED-BLACK TREES

 Definition: a binary search tree with nodes colored red and

black such that:
 the paths from the root to any leaf have the same number
of black nodes,
 there are no two consecutive red nodes, If a node is red,
then both of its children are black
 the root is black.
 A red-black tree of height for h even and h odd

The total number of leaves is of the form:

1 + 2i1 + 2i2 + 2i3 +· · ·+2ih ,

So for h even the number of leaves is:

1 + 2(20 + 21 + 22 +· · ·+2(h/2)−1) = 2(h/2)+1 − 1,

and for h odd it is:

1 + 2(20 + 21 + 22 +· · ·+2((h−1)/2)−1) + 2(h−1)/2 = 2(h−1)/2 − 1

So the worst-case height of a red-black tree is really 2 log n − O(1).

 The height of red-black tree

Definition: The black-height of a node, x, in a red-black tree is the

number of black nodes on any path to a leaf, not counting x.

Black-Height of the root = 2

Black-Height of the root = 3
 Height-balanced trees

We have to maintain the following balancedness property

- Each path from the root to a leaf contains the same number of black nodes

bh =2
7

bh =1 3 18 bh =2

bh =1 10 22 bh =1

bh =1 8 11 26 bh =1
 Rotation
A rotation is a local operation in a search tree that preserves in-order traversal
key ordering.
 Bottom-Up Rebalancing for Red-Black Trees

* The idea for insertion in a red-black tree is to insert like in a binary search tree
and then reestablish the color properties through a sequence of recoloring and
rotations
The rules are as follows:
1. If other is red, color current and other black and upper red.
2. If current = upper->left
2.1 If current->right->color is black,
perform a right rotation around upper and color upper->right
red.
2.2 If current->right->color is red,
perform a left rotation around current followed by a right rotation
around upper, and color upper->right and upper->left
black and upper red.
3. If current = upper->right
3.1 If current->left->color is black,
perform a left rotation around upper and color upper->left red.
3.2 If current->left->color is red,
perform a right rotation around current followed by a left rotation
around upper, and color upper->right and upper->left
black and upper red.
* We have 3 cases for insertion

Case 1: Recolor (uncle is red)

G G

P U P U
 Case 2:
Double Rotate: X around P then X around G.
Recolor G and X

G X

P P
U G

X
S
U
S
Case 3:
Single Rotate P around G
Recolor P and G

P
P U

X
G
S
X

S U
 Analysis of Insertion
- A red-black tree has O(log n) height
- Search for insertion location takes O(log n) time because we
visit O(log n) nodes
- Addition to the node takes O(1) time
- Rotation or recoloring takes O(log n) time because we
perform
* O(log n) recoloring, each taking O(1) time, and
* at most one rotation taking O(1) time
- Thus, an insertion in a red-black tree takes O(log n) time
• Deleting a node from a red-black tree is a bit more
complicated than inserting a node.

- If the node is red?

Not a problem – no RB properties violated

- If the node is black?

deleting it will change the black-height along some path
* We have some cases for deletion

delete
U S

Case A:
- V’s sibling, S, is Red
Rotate S around P and recolor S & P
 S
P
Rotate S around P
P
V S

S
Recolor S &
P
P

V
 P

delete S
U

Case B:
- V’s sibling, S, is black and has two black children.
Recolor S to be Red

Red or Black and don’t care

 Recolor S to be Red
P P

S V S
V
 P

delete S
U

Case C:
- S is black
S’s RIGHT child is RED (Left child either color)
Rotate S around P
Swap colors of S and P, and color S’s Right child Black
 S
P
Rotate S around P
P
S
V

P
Recolor: Swap colors of S and
P, and color S’s Right child
V Black
 P

delete S
U

Case D:
- S is Black, S’s right child is Black and S’s left child is Red
i) Rotate S’s left child around S
ii) Swap color of S and S’s left child
 P

P
S
V

V
P
S
Rotate S’s
left child
V
around S
S
Recolor: Swap
color of S and S’s
left child
 Analysis of deletion

- A red-black tree has O(log n) height

- Search for deletion location takes O(log n) time
- The swaping and deletion is O(1).
- Each rotation or recoloring is O(1).
- Thus, the deletion in a red-black tree takes O(log n) time
RED BLACK TREES

 Top-Down Insertion
REVIEW OF BOTTOM-UP INSERTION
 In B-Up insertion, “ordinary” BST insertion was used,
followed by correction of the tree on the way back up to
the root
 This is most easily done recursively
 Insert winds up the recursion on the way down the tree to the
insertion point
 Fixing the tree occurs as the recursion unwinds
TOP-DOWN INSERTION STRATEGY
 In T-Down insertion, the corrections are done while
traversing down the tree to the insertion point.
 When the actual insertion is done, no further corrections
are needed, so no need to traverse back up the tree.
 So, T-Down insertion can be done iteratively which is
generally faster
 GOAL OF T-D INSERTION
 Insertion is always done as a leaf (as in ordinary BST
insertion)
 Recall from the B-Up flow chart that if the uncle of a
newly inserted node is black, we restore the RB tree
properties by one or two local rotations and recoloring – we
do not need to make changes further up the tree
 GOAL (2)
 Therefore, the goal of T-D insertion is to traverse from the
root to the insertion point in such a way that RB properties
are maintained, and at the insertion point, the uncle is
Black.

 That way we may have to rotate and recolor, but not

propagate back up the tree
POSSIBLE INSERTION CONFIGURATIONS

X (Red or Black)

Y Z

If a new node is inserted as a child of Y or Z, there is no

problem since the new node’s parent is black
Possible insertion configurations

Y Z

If new node is child of Z, no problem since Z is black.

If new node is child of Y, no problem since the new node’s
uncle (Z) is black – do a few rotations and recolor…. done
POSSIBLE INSERTION CONFIGURATIONS

Y Z

If new node is inserted as child of Y or Z, it’s uncle will be

red and we will have to go back up the tree. This is the
only case we need to avoid.
TOP-DOWN TRAVERSAL

As we traverse down the tree and

X encounter this case, we recolor and
possible do some rotations.
Y Z
There are 3 cases.

Remember the goal – to create an insertion point at which the

parent of the new node is Black, or the uncle of the new node
is black.
CASE 1 – X’S PARENT IS BLACK

P P

X X
Y Z Y Z

Just recolor and continue down the tree

CASE 2
 X’s Parent is Red (so Grandparent is Black) and X and P
are both left/right children
 Rotate P around G
 Color P black
 Color G red
 Note that X’s uncle, U, must be black because it (a) was
initially black, or (b) would have been made black when we
encountered G (which would have had two red children --
X’s Parent and X’s uncle)
 CASE 2 DIAGRAMS

G P
P U
G
X
X S Z
Y Z Y S U

Rotate P around G. Recolor X, Y, Z, P and G

 Case 3
• X’s Parent is Red (so Grandparent is Black)
and X and P are opposite children
– Rotate P around G
– Color P black
– Color G red
• Again note that X’s uncle, U, must be black
because it (a) was initially black, or (b)
would have been made black when we
encountered G (which would have had two
red children -- X’s Parent and X’s uncle)
 CASE 3 DIAGRAMS (1 OF 2)

G G
X U
P U

S X P Z
S Y
Y Z

Step 1 – recolor X, Y and Z. Rotate X around P.

 CASE 3 DIAGRAMS (2 OF 2)

G X

X U G
P

P Z
S Y Z U
S Y

Step 2 – Rotate X around G. Recolor X and G

 TOP-DOWN INSERT SUMMARY
Case 1 Recolor
P is Black X,Y,Z
P P
Just Recolor
X X

Y Z Y Z

Case 2
P is Red
G G Rotate P P
X & P both left/right
Recolor around G G
X,Y,Z Recolor P,G X
P P
Y Z
X X

Y Z Y Z

Case 3 G G X
P is Red Recolor X,Y,Z Rotate X G
X and P are Rotate X X around G P
P
opposite children around P Recolor X, G
P
X
Y Z Y Z
Y Z
39
40
41
42
ANOTHER EXAMPLE

43
44
85

45
85

46
47
48
49
50
51
RED BLACK TREES

Top-Down Deletion
RECALL THE RULES FOR BST DELETION
1. If a node to be deleted is a leaf, just delete it.
2. If a node to be deleted has just one child, replace it
with that child
3. If a node to be deleted has two children, replace the
value of by it’s in-order predecessor’s value then
delete the in-order predecessor (a recursive step)
WHAT CAN GO WRONG?
1. If the delete node is red?

Not a problem – no RB properties violated

2. If the deleted node is black?

If the node is not the root, deleting it will change the

black-height along some path
TERMINOLOGY
 Matching Weiss text section 12.2
X is the node being examined
 T is X’s sibling
 P is X’s (and T’s) parent
 R is T’s right child
 L is T’s left child.
BASIC STRATEGY
 As we traverse the tree, we change every node we visit,
X, to Red.
 When we change X to Red, we know
 P is also Red (we just came from there)
 T is black (since P is Red, it’s children are Black)
STEP 1 – EXAMINE THE ROOT
1. If both of the root’s children are Black
a. Make the root Red
b. Move X to the appropriate child of the root
c. Proceed to step 2
2. Otherwise designate the root as X and proceed to step
2B.
STEP 2 – THE MAIN CASE

As we traverse down the tree, we continually encounter this

situation until we reach the node to be deleted
X is Black, P is Red, T is Black

We are going to color X Red, then recolor other nodes and

possibly do rotation(s) based on the color of X’s and T’s
children
2A. X has 2 Black children
2B. X has at least one Red child
CASE 2A
X HAS TWO BLACK CHILDREN

2A1. T has 2 Black Children

P 2A2. T’s left child is Red
X T
2A3. T’s right child is Red

** if both of T’s children are Red,

we can do either 2A2 or 2A3
CASE 2A1
X AND T HAVE 2 BLACK CHILDREN

P P
X T X T

Just recolor X, P and T and move down the tree

CASE 2A2

X has 2 Black Children and T’s Left Child is Red

Rotate L around T, then L around P
Recolor X and P then continue down the tree
L
P
P T
X T
L
X L1 L2

L1 L2
 Case 2A3
X has 2 Black Children and T’s Right Child is Red
Rotate T around P
Recolor X, P, T and R then continue down the tree

T
P
X T P R
R
X R1 R2
L L
R1 R2
CASE 2B
X HAS AT LEAST ONE RED CHILD
Continue down the tree to the next level
If the new X is Red, continue down again
If the new X is Black (T is Red, P is Black)
Rotate T around P
Recolor P and T
Back to main case – step 2
 CASE 2B DIAGRAM

P
X T

Move down the tree.

P P
X T T X

If move to Black child (2B2) If move to the Red child (2B1)

Rotate T around P; Recolor P and T Move down again
Back to step 2, the main case
STEP 3

Eventually, find the node to be deleted – a leaf or a node with

one non-null child that is a leaf.
Delete the appropriate node as a Red leaf

Step 4
Color the Root Black
EXAMPLE 1
DELETE 10 FROM THIS RB TREE

15

6 17

12 20
3 16

10 13 18 23

Step 1 – Root has 2 Black children. Color Root Red

Descend the tree, moving X to 6
EXAMPLE 1 (CONT’D)

15

X 6 17

12 20
3 16

10 13 18 23

One of X’s children is Red (case 2B). Descend down the

tree, arriving at 12. Since the new X (12) is also Red (2B1),
continue down the tree, arriving at 10.
 Example 1 (cont’d)
15

6 17

12 20
3 16

10 13 18 23
X
7

Step 3 -Since 10 is the node to be deleted, replace it’s value

with the value of it’s only child (7) and delete 7’s red node
 Example 1 (cont’d)
15

6 17

12 20
3 16

7 13 18 23

The final tree after 7 has replaced 10 and 7’s red node
deleted and (step 4) the root has been colored Black.
TREES WITH CONSTANT UPDATE
TIME AT A KNOWN LOCATION

 The insertion and deletion operations, along with the tree

rearrangement and recoloring, are performed
in O(log n) time.
 insertion will take O(1), if the location is already known.

70
 Finger Trees and Level Linking

The idea of finger trees is that searching for an element

should be faster if the position of a nearby element is
known. This nearby element is known as the “finger.” The
search time should not depend on the total size of the
underlying set S, but only on the neighborhood or distance
from the finger f to the element q that is searched.
 The finger search method

A finger search method could have the following outline: go

from the finger leaf several levels up, move in the list of nodes
at level i in the right direction till the subtree with the query
element is found, and then go down in the tree again to the
query element
- The paths from the root to the leaves have different lengths

* We need to maintain two conditions:

1. within each level, the intervals associated with the nodes form a
partition
of ]−∞,∞[
2. along each path from the root to a leaf, the number of nodes
between two
nodes of consecutive levels is bounded by a constant C.
 2-3 tree of integers

To make it a finger tree, what you do, in theory, is reach down to the leftmost
and rightmost internal nodes of the tree – in our case, the parents of (1,2) and
(8, 9, 10). Then you pick up the tree by those two nodes, and let the rest
dangle down.
If you look at this, you’ve got a finger for the node (1,2), and a finger for the node
(8,9,10). In between them, you’ve got a bunch of stuff dangling. But if you look at
the dangling stuff: it’s a finger tree.