CSE2331/5331. Topic 7: Balanced search trees. Rotate operation Red-black tree Augmenting data struct. CSE 2331/5331

Transcription

1 CSE2331/5331 Topic 7: Balanced search trees Rotate operation Red-black tree Augmenting data struct.

2 Set Operations Maximum Extract-Max Insert Increase-key Search Delete Successor Predecessor

3 Motivation Using binary search trees, most operations take time O(h) with h being the height of the tree Want to keep h small h = Θ(log nn) the best one can hope for. (why?) We can sort the elements, and construct a balanced binary search tree But then how do we maintain it under dynamic operations (insertion / deletion)?

4 Balanced Search Tree

5 Un-balanced Search Tree

6 Goal: Maintain a balanced binary search tree with height Θ(lg nn) such that all operations take OO(lg nn) Maintain means that the tree is always of height Θ(lg(#eeeeeeeeeeeeeeee)) after any operation supported, especially insertion and deletion. There are multiple such balanced trees We focus on the so-called Red-black trees

7 Rotation Operation A key operation in maintaining the balance of a binary search tree Locally rotate subtree, while maintain binary search tree property x right rotation y y C left rotation A x A B B C

8 Right Rotation Examples Right rotation at 9. Right rotation at at 13 7? Does it change Binary search tree property?

9 Left Rotation Examples Left rotation at node 3. what if we then right-rotate at node 6? left and right rotations are inverse of each other.

10 Recall: Transplant

11 Implementation of Right Rotation Running time: Θ(1)

12 Implementation of Left Rotation Running time: Θ(1)

13 Rotation does not change binary search tree property! x right rotation y y C left rotation A x A B B C

14 Rotation to Re-balance Apply rotation to node 5 Reduce height to 3!

15 Rotation to Re-balance Apply rotation at node 5 Height not reduced! Need a double-rotation (first at 16, then at 5) In general, how and when?

16 Red-Black Trees Compared to an ordinary binary tree, a red-black binary tree: A leaf node is NIL Hence all nodes are either NIL or have exactly two children! Each node will have a color, either red or black

17 Definition A Red-Black tree is a binary tree with the following properties: Every node is either red or black Root is black Every leaf is NIL and is black If a node is red, then both its children are black For each node, all simple paths from this node to its decedent leaves contain same number of black nodes

18 An Example Double nodes are black. No two consecutive red nodes.

19 Skipping Leaves

20 Is This a Red-Black Tree?

21 Exercise Color the following tree to make a valid red-black tree

22 Given a tree node x size(x): the total number of internal nodes contained in the subtree rooted at x bh(x): the number of black nodes on the path from x to leaf (not counting x)

23 Balancing Property of RB-tree Lemma [BN-Bound]: Let r be the root of tree T. Then ssssssss rr 2 bbb rr 1. Proof: Since every root-leaf path has bbb(rr) black nodes, TT contains a complete binary tree of height bbb(rr) as subtree. For a complete binary tree of height bbb(rr), its size is 2 bbb xx 1 Hence ssssssss rr 2 bbb rr 1

24 Balancing Property of RB-tree Theorem [RB-Height] A red-black tree with n internal nodes has height h 2 log 2 (nn + 1). Proof: Let r be the root of this red-black tree Since no red node has a red child, bbb rr h 2 By Lemma [BN-Bound], nn 2 bbb rr 1 2 h/2 1 Thus, h 2 log 2 nn + 1

25 Implication of the Theorem In other words, if we can maintain a RB-tree under every operation, then the tree always has Θ(lg nn) height, and All operations thus all take OO(lg nn) time. How to maintain RB-tree under Operations?

26 Set Operations Maximum Extract-Max Insert Increase-key Search Delete Successor Predecessor Only need to consider Insert / delete

27 Insertion Example Insert 24? 36? 2?

28 Red-Black Tree Insert

29 Insert Fixup: Case 3 (z is the new node)

30 Example: Case 3 Insert 12?

31 Implementation of Fixup Case 3

32 Remarks Running time of RBInsertFixupC Θ 1 If the tree has red-black properties if not counting violation caused by z Then after RBInsertFixupC the tree is a red-black tree! No more operations needed.

33 Insert Fixup: Case 2

34 Example: Case 2 Insert 14?

35 Implementation of Case 2 Running time Θ 1

36 Insert Fixup: Case 1: (z is new node) The parent and uncle of z are red: Color the parent and uncle of z both black Color the grandparent of z red Continue with the grandparent of z

37 Sibling Takes Θ 1 time

38 Implementation of Case 1 Running time: Θ h = Θ(lg nn) When does this procedure terminate?

39 Red-black Tree Insert Fixup Function RBInsertFixup (T, z) RBInsertFixupA (T, z); RBInsertFixupB (T, z); RBInsertFixupC (T, z); T.root.color = Black; Note z changes after each call. Total time copmlexity: Θ(lg nn) Total # rotations: At most 2

40 Example Insert 21?

41 Augmenting Data Structure

42 Balanced Binary Search Tree Maximum Extract-Max Insert Increase-key Search Delete Successor Predecessor Also support Select operation?

43 Augment Tree Structure Select ( T, k ) Goal: Augment the binary search tree data structure so as to support Select ( T, k ) efficiently Ordinary binary search tree O(h) time for Select(T, k) Red-black tree (balanced search tree) O(lg n) time for Select(T, k)

44 How To Augment Tree Structure? At each node x of the tree T store x.size = # nodes in the subtree rooted at x Include x itself If a node (leaf) is NIL, its size is 0. Space of an augmented tree: Θ nn Basic property: xx. ssssssss = xx. llllllll. ssssssss + xx. rrrrrrrrr. ssssssss + 1

45 Example M 9 C 5 P 3 A 1 F 3 T 2 D 1 H 1 Q 1

46 How to Setup Size Information? procedure AugmentSize( tttttttttttttttt xx ) If (xx NNNNNN ) then LLLLLLLLLL = AugmentSize( xx. llllllll ); RRRRRRRRRR = AugmentSize( xx. rrrrrrrrr); xx. ssssssss = LLLLLLLLLL + RRRRRRRRRR + 1; Return( xx. ssssssss ); end Return (0); Postorder traversal of the tree!

47 Augmented Binary Search Tree Let T be an augmented binary search tree OS-Select(x, k): Return the k-th smallest element in the subtree rooted at x OS-Select(T.root, k) returns the k-th smallest elements in the entire tree. OS-Select(T.root, 5)?

48 Correctness? Running time? O(h)

49 OS-Rank(T, x) Return the rank of the element x in the linear order determined by an inorder walk of T

50 Example M 9 C 5 P 3 A 1 F 3 T 2 OS-Rank(T, M) D)? D 1 H 1 Q 1

51 Correctness? Time complexity? O(h)

52 Are we done? Need to maintain augmented information under dynamic operations Insert / delete Extract-Max can be implemented with delete

53 Example M 9 C 5 P 3 A 1 F 3 T 2 Insert(J)? D 1 H 1 Q 1

54 During the downward search, increase the size attribute of each node visited along the path from root to the final insert location. Time complexity: O(h) However, if we have to maintain balanced binary search tree, say Red-black tree Also need to adjust size attribute after rotation

55 Left-Rotate y.size = x.size x.size = x.left.size + x.right.size + 1 O(1) time per rotation

56 Right-rotate can be done similarly. Overall: Two phases: Update size for all nodes along the path from root to insertion location O(h) = O(lg n) time Update size for the Fixup stage involving O(1) rotations O(1) + O(lg n) = O(lg n) time O(h) = O(lg n) time to insert in a Red-Black tree Same asymptotic time complexity as the non-augmented version

57 Delete Two phases: Decrement size in each node on the path from the root to the node to be deleted O(h) = O(lg n) time During Fixup (to maintain balanced binary search tree property), update size for O(1) rotations O(1) + O(lg n) time Overall: O(h) = O(lg n) time

58 Summary Simple example of augmenting data structures In general, the augmented information can be quite complicated Can be a separate data structure! Need to consider how to maintain such information under dynamic changes