1. October 16, 20031 Algorithms and Data Structures Lecture IX Simonas Šaltenis Aalborg University simas@cs.auc.dk

2. October 16, 20032 This Lecture Red-Black Trees Properties Rotations Insertion Deletion

3. October 16, 20033 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)

4. October 16, 20034 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)

5. October 16, 20035 RB-Tree Properties (1) Some measures n – # of internal nodes h – height bh – black height 2 bh – 1  n bh  h/2 2 h/2  n +1 h/2  lg(n +1) h  2 lg(n +1)

6. October 16, 20036 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)

7. October 16, 20037 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

8. October 16, 20038 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

9. October 16, 20039 Rotation right rotation of B left rotation of A A B    B A   

10. October 16, 200310 Right Rotation RightRotate(B) 01 A  B.left() Move  02 B.setLeft(A.right()) 03 A.right().setParent(B) Move A 04 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

11. October 16, 200311 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

12. October 16, 200312 Insertion in the RB-Trees RBInsert(T,n) 01 Insert n into T using the normal binary search tree insertion procedure 02 n.setLeft(nil) 03 n.setRight(nil) 04 n.setColor(red) 05 RBIsertFixup(n)

13. October 16, 200313 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()

14. October 16, 200314 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

15. October 16, 200315 Insertion: Case 1 (2) We call this a promotion Note how the black depth remains unchanged for all of the descendants of g

16. October 16, 200316 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!

17. October 16, 200317 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!

18. October 16, 200318 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!

19. October 16, 200319 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. 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 do 04 if p = g.left() then 05 if g.right().color() = red 06 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  p 13 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

21. October 16, 200321 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)

22. October 16, 200322 Inserting "REDSOX" into an empty tree Now, let us insert "CUBS" An Insertion Example

23. October 16, 200323 Example C

24. October 16, 200324 Example U

25. October 16, 200325 Example U (2) Double Rotation

26. October 16, 200326 Example B What now?

27. October 16, 200327 Example B (2) Right Rotation on D

28. October 16, 200328 Example S two red edges and red uncle X- promotion

29. October 16, 200329 Example S (2) again two red edges - rotation

30. October 16, 200330 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

31. October 16, 200331 Deletion Algorithm 1. Remove v 2. 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.

32. October 16, 200332 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

33. October 16, 200333 Deletion Case 2 If sibling and its children are black, perform a recoloring If parent becomes double black, continue upward

34. October 16, 200334 Deletion: Cases 3 and 4 If sibling is black and one of its children is red, perform a restructuring

35. October 16, 200335 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)

36. October 16, 200336 A Deletion Example Delete 9

37. October 16, 200337 A Deletion Example (2) Case 2 (sibling is black with black children) – recoloring

38. October 16, 200338 A Deletion Example (3) Delete 8: no double black

39. October 16, 200339 A Deletion Example (4) Delete 7: restructuring

40. October 16, 200340 How long does it take? Deletion in a RB-tree takes O(log n) Maximum three rotations and O(log n) recolorings

41. October 16, 200341 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

42. October 16, 200342 Next Week Solving optimization problems using Dynamic Programming “Improved version” of divide-and-conquer