October 16, 2003 1

Algorithms and Data StructuresLecture IX

Simonas ŠaltenisAalborg Universitysimas@cs.auc.dk

October 16, 2003 2

This Lecture

Red-Black Trees Properties Rotations Insertion Deletion

October 16, 2003 3

Balanced Binary Search Trees

Problem: execution time for dynamic set operations is (h), which in worst case is (n)

Solution: balanced search trees guarantee small height – h = O(log n)

October 16, 2003 4

Red/Black Trees A red-black tree is a binary search tree with the

following properties: Nodes (incoming edges) are colored red or black Nil-pointer leaves are black The root is black

No two consecutive red edges on any root-leaf path

Same number of black edges on any root-leaf path (= black height of the tree)

October 16, 2003 5

RB-Tree Properties (1)

Some measures n – # of internal nodes h – height bh – black height

2bh – 1 n bh h/2 2h/2 n +1 h/2 lg(n +1) h 2 lg(n +1)

October 16, 2003 6

Operations in the binary-search tree (search, insert, delete, ...) can be accomplished in O(h) time

The RB-tree is a binary search tree, whose height is bound by 2 log(n +1), thus the operations run in O(log n) Provided that we can maintain red-black

tree properties spending no more than O(h) time on each insertion or deletion

RB-Tree Properties (2)

October 16, 2003 7

Red-Black Tree ADT

RBTree ADT: Accessor functions:

key():int color(): {red, black} parent(): RBTree left(): RBTree right(): RBTree

Modification procedures: setKey(k:int) setColor(c:{red, black}) setParent(T:RBTree) setLeft(T:RBTree) setRight(T:RBTree)

nil

October 16, 2003 8

NIL Sentinel

To simplify algorithms we have a special instance of the RBTree ADT – nil : nil.color() = black nil.right() = nil.left() = root of the tree parent() of the root node = nil nil.parent() and nil.key() – undefined

October 16, 2003 9

Rotation

right rotation of B

left rotation of A

A

B

B

A

October 16, 2003 10

Right Rotation

RightRotate(B)01 A B.left() Move 02 B.setLeft(A.right())03 A.right().setParent(B) Move A04 if B = B.parent().left() then B.parent().setLeft(A)05 if B = B.parent().right() then B.parent().setRight(A)06 A.setParent(B.parent()) Move B 07 A.setRight(B) 08 B.setParent(A)

A

B

B

A

October 16, 2003 11

The Effect of a Rotation Maintains inorder key ordering

After right rotation Depth() decreases by 1 Depth() stays the same Depth() increases by 1

Rotation takes O(1) time

, ,

we can state the invariant

a b c

a A b B c

October 16, 2003 12

Insertion in the RB-Trees

RBInsert(T,n)01 Insert n into T using the normal binary search tree insertion

procedure02 n.setLeft(nil)03 n.setRight(nil)04 n.setColor(red)05 RBIsertFixup(n)

October 16, 2003 13

Insertion, Plain and Simple

Let n = the new node p = n.parent() g = p.parent()

Case 0: p.color() = black No properties of the tree are

violated – we are done! In the following assume:

p = g.left()

October 16, 2003 14

Insertion: Case 1

Case 1: p.color() = red and g.right().color() = red (parent and its sibling are red) a tree rooted at g is balanced enough!

01 p.setColor(black)02 g.right().setColor(black)03 g.setColor(red)04 n g // and update p and g

October 16, 2003 15

Insertion: Case 1 (2)

We call this a promotion Note how the black depth remains

unchanged for all of the descendants of g

October 16, 2003 16

Insertion: Case 3

Case 3: p.color() = red and g.right().color() = black n = p.left()

01 p.setColor(black)02 g.setColor(red)03 RightRotate(g)04 // we are done!

October 16, 2003 17

Insertion: Case 3 (2)

We do a right rotation and two re-colorings Tree becomes more balanced Black depths remain unchanged No further work on the tree is necessary!

October 16, 2003 18

Insertion: Case 2

Case 2: p.color() = red and g.right().color() = black n = p.right()

01 LeftRotate(p)02 exchange n and p pointers and do as in case 3!

October 16, 2003 19

Insertion: Mirror cases

All three cases are handled analogously if p is a right child For example, case 2 and 3 – right-left

double rotation

20

Insertion: Pseudo Code

Case 1

Case 2

Case 3

RBInsertFixup(n)01 p n.parent()02 g p.parent()03 while p.color() = red do04 if p = g.left() then 05 if g.right().color() = red06 then p.setColor(black)07 g.right().setColor(black)08 g.setColor(red)09 n g // and update p and g, as in 01,02 10 else if n = p.right() 11 then LeftRotate(p)12 exchange n p13 p.setColor(black)14 g.setColor(red)15 RightRotate(g)16 else (same as then clause with ”right” and ”left”

exchanged)17 nil.left().setColor(black) // set the color of root to

black

October 16, 2003 21

Insertion Summary

If two red edges are present, we do either a restructuring (with a simple or double

rotation) and stop (cases 2 and 3), or a promotion and continue (case 1)

A restructuring takes constant time and is performed at most once. It reorganizes an off-balanced section of the tree

Promotions may continue up the tree and are executed O(log n) times (height of the tree)

The running time of an insertion is O(log n)

October 16, 2003 22

Inserting "REDSOX" into an empty tree

Now, let us insert "CUBS"

An Insertion Example

October 16, 2003 23

Example C

October 16, 2003 24

Example U

October 16, 2003 25

Example U (2)

Double Rotation

October 16, 2003 26

Example B

What now?

October 16, 2003 27

Example B (2)

Right Rotation on D

October 16, 2003 28

Example S

two red edges and red uncle X- promotion

October 16, 2003 29

Example S (2)again two red edges - rotation

October 16, 2003 30

Deletion

As with binary search trees, we can always delete a node that has at least one nil child

If the key to be deleted is stored at a node that has no external children, we move there the key of its in-order successor, and delete that node instead

October 16, 2003 31

Deletion Algorithm1. Remove v2. If v.color() = red, we are done! Else, assume that u (v’s non-nil child or

nil) gets additional black color: If u.color() = red then u.setColor(black) and we are done! Else u’ s color is double black.

October 16, 2003 32

Deletion Algorithm (2)

How to eliminate double black edges? The intuitive idea is to perform a "color

compensation" Find a red edge nearby, and change the pair (red,

double black) into (black, black) We have two cases :

restructuring, and recoloring

Restructuring resolves the problem locally, while recoloring may propagate it two levels up

Slightly more complicated than insertion

October 16, 2003 33

Deletion Case 2

If sibling and its children are black, perform a recoloring

If parent becomes double black, continue upward

October 16, 2003 34

Deletion: Cases 3 and 4

If sibling is black and one of its children is red, perform a restructuring

October 16, 2003 35

Deletion Case 1

If sibling is red, perform a rotation to get into one of cases 2, 3, and 4

If the next case is 2 (recoloring), there is no propagation upward (parent is now red)

October 16, 2003 36

A Deletion Example

Delete 9

October 16, 2003 37

A Deletion Example (2)

Case 2 (sibling is black with black children) – recoloring

October 16, 2003 38

A Deletion Example (3)

Delete 8: no double black

October 16, 2003 39

A Deletion Example (4)

Delete 7: restructuring

October 16, 2003 40

How long does it take?

Deletion in a RB-tree takes O(log n) Maximum three rotations and O(log n)

recolorings

October 16, 2003 41

Red-Black trees are related to 2-3-4 trees (non-binary trees)

Other balanced trees

AVL-trees have simpler algorithms, but may perform a lot of rotations

October 16, 2003 42

Next Week

Solving optimization problems using Dynamic Programming “Improved version” of divide-and-

conquer