Algorithms and Data Structures Lecture IX

1. Algorithms and Data StructuresLecture IX Simonas Šaltenis Aalborg University simas@cs.auc.dk

2. This Lecture • Red-Black Trees • Properties • Rotations • Insertion • Deletion

3. Balanced Binary Search Trees • Problem: execution time for dynamic set operations is Q(h), which in worst case is Q(n) • Solution: balanced search trees guarantee small height – h = O(log n)

4. Red/Black Trees • Ared-black treeis a binary search tree with the following properties: • Nodes (incoming edges) are colored redor black • Nil-pointer leaves are black • The root is black • No two consecutiverededgeson any root-leaf path • Same number of black edgeson any root-leaf path (= black heightof the tree)

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)

6. RB-Tree Properties (2) • 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

7. nil 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)

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

9. B A A B left rotation of A Rotation a g a g b b right rotation of B

10. Right Rotation A B A B a g RightRotate(B) 01 A ¬ B.left() Moveb 02 B.setLeft(A.right()) 03 A.right().setParent(B) Move A 04 ifB = B.parent().left()then B.parent().setLeft(A) 05 ifB = B.parent().right()then B.parent().setRight(A) 06 A.setParent(B.parent()) Move B 07 A.setRight(B) 08 B.setParent(A) a g b b

11. The Effect of a Rotation • Maintains inorder key ordering • After right rotation • Depth(a) decreases by 1 • Depth(b) stays the same • Depth(g) increases by 1 • Rotation takes O(1) time

12. Insertion in the RB-Trees RBInsert(T,n) 01Insert 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. 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. Insertion: Case 1 • Case 1: • p.color() = red and g.right().color() = red (parent and its sibling are red) • a tree rooted at gis balanced enough! 01 p.setColor(black) 02 g.right().setColor(black) 03 g.setColor(red) 04 n¬ g // and updatep and g

15. Insertion: Case 1 (2) • We call this a promotion • Note how the black depth remains unchanged for all of the descendants ofg

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!

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!

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!

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 RBInsertFixup(n) 01p¬n.parent() 02 g¬p.parent() 03whilep.color() = red do 04 if p = g.left() then 05 ifg.right().color() = red 06 thenp.setColor(black) 07 g.right().setColor(black) 08 g.setColor(red) 09 n¬ g // and updatep and g, as in 01,02 10 elseif n=p.right() 11 then LeftRotate(p) 12 exchangen«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 Case 1 Case 2 Case 3

21. Insertion Summary • If twored edgesare 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 timeof an insertion is O(log n)

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

23. Example C

24. Example U

25. Double Rotation Example U (2)

26. Example B What now?

27. Example B (2) Right Rotation on D

28. Example S two red edges and red uncle X- promotion

29. again two red edges - rotation Example S (2)

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

31. Deletion Algorithm 1. Remove v 2. If v.color() = red, we are done! Else, assume that u(v’s non-nilchild or nil)getsadditional black color: • If u.color() = redthenu.setColor(black) and we are done! • Else u’ s color isdouble black.

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

33. Deletion Case 2 • If sibling and its children are black, perform a recoloring • If parent becomes double black, continueupward

34. Deletion: Cases 3 and 4 • If sibling is blackand one of its children is red, perform a restructuring

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)

36. A Deletion Example • Delete 9

37. A Deletion Example (2) • Case 2 (sibling is black with black children) – recoloring

38. A Deletion Example (3) • Delete 8: no double black

39. A Deletion Example (4) • Delete 7: restructuring

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

41. Other balanced trees • Red-Black trees are related to 2-3-4 trees (non-binary trees) • AVL-trees have simpler algorithms, but may perform a lot of rotations

42. Next Week • Solving optimization problems using Dynamic Programming • “Improved version” of divide-and-conquer