Design Patterns for Data Structures. Chapter 10. Balanced Trees

Transcription

1 Capter 10 Balanced Trees

2 Capter 10 Four eigt-balanced trees: Red-Black binary tree Faster tan AVL for insertion and removal Adelsen-Velskii Landis (AVL) binary tree Faster tan red-black for lookup B-tree n-way balanced tree Nguyen-Wong B-trees Composite pattern n-way balanced tree

3 Demo Insert:

4 Capter 10 Properties of a red-black tree Ared-black tree is a binary searc tree. Every link is eiter red or black. Every cild tat is an empty tree is a leaf wit a black link to its parent. No pat from te root to any leaf as two red links in a row. All pats from eac node to all its leaves ave te same number of black links.

5 Capter 10 Properties of a left-leaning red-black tree A left-leaning red-black tree is a red-black tree. Every red link is to a left cild. Sedgewick, as sown tat tis restriction greatly simplifies te code for bot insertion and deletion.

6 Capter 10 Te number of black links from te root to any leaf is called te black eigt of te tree, denoted b ( ) = b (60) = 3

7 Performance of

8 Lemma 1: No pat from te root to a leaf is more tan twice as long as any oter. In a red-black tree of eigt rooted at x, b(x) /2. x b x =

9 Define n x, as te number of internal nodes in a red-black tree of eigt rooted at node x. Example: n 60, 6 = 16 Example: n20, 4 = =

10 Lemma 2: n x, 2 b(x) 1. Proof : Te proof is by matematical induction on te eigt of te tree. Base case: n x, 2 b(x) 1 = Take as te base case tat te root is n, 2 b() 1 = Wit a root of, tere are no internal nodes 0 2 b() 1 = Wit a root of, te black eigt is = Mat true

11 Induction case: Must prove tatn x, 2 b(x) 1 for a eigt tree using n w, 1 2 b(w) 1 for a eigt 1 tree as te inductive ypotesis. x c Link from x to cild c is red => b(c) = b(x). Link from x to cild c is black => b(c) = b(x) 1. Minimum number of nodes in tree rooted at x => bot cildren ave minimum => links from x to bot are black

12 Induction case: Must prove tatn x, 2 b(x) 1 for a eigt tree using n w, 1 2 b(w) 1 for a eigt 1 tree as te inductive ypotesis. x c n x, = 1 + n l, 1 + n r, b(l) b(r) 1 l r b(x) b(x) 1 1 = 2 2 b(x) 1 1 = 2 b(x) 1

13 n x, 2 /2 1 n x, 2 b(x) 1 2 /2 1

14 Teorem, red-black tree eigt bound: Ared-black tree witn internal nodes as eigt 2lg(n + 1). Proof : Starting wit Lemma 3, n 2 /2 1 = Mat 2 /2 n + 1 = Take lg of bot sides, monotonicity of lg() /2 lg(n + 1) = Mat 2lg(n + 1) For comparison, eigt-balanced AVL trees ave 1.44lg(n+2) Tey are more balanced tan red-black trees and ave faster retrieval (1.44 coefficient compared to 2 for red-black trees) but ave slower insertion and removal.

15 Implementation of

16 template<class T> class { private: Node<T> *_root; public: (); //Constructor // Post: Tis left-leaning red-black tree // is initialized to be empty. ~(); //Destructor // Post: Tis left-leaning red-black tree // is deallocated.

17 bool contains(t const &data); // Post: Returns true if tis tree contains data. void insert(t const &data); // Post: data is stored in tis tree in order // wit no duplicates. bool isempty(); // Post: Returns true if tis tree is empty.

18 void remove(t const &data); // Pre: Tis tree contains data. // Post: data is removed from tis tree. void removemin(); // Pre: Tis tree is not empty. // Post: Te minimum value is removed. }; void tostream(ostream &os) const; // Post: A string representation of tis tree // is streamed to os.

19 template<class T> class Node { friend class <T>; private: Node *_left; T _data; Node *_rigt; bool _color; // Color of link from parent.

20 public: Node(T data); // Post: Tis node is allocated wit _data set to data, // _color set to RED, and _left, _rigt set to nullptr. ~Node(); // Post: Tis node, its left subtree, and its rigt subtree // are deallocated.

21 private: Node<T> *fixup(node<t> *); void flipcolors(node<t> *); Node<T> *insert(node<t> *, T const &data); bool isred(node<t> *); T min(node<t> *); Node<T> *moveredleft(node<t> *); Node<T> *moveredrigt(node<t> *); Node<T> *remove(node<t> *, T const &data); Node<T> *removemin(node<t> *); Node<T> *rotateleft(node<t> *); Node<T> *rotaterigt(node<t> *); void tostream(node<t> *, string prrigt, string prroot, string prleft, ostream &os) const; };

22 const bool RED = true; const bool BLACK = false; template<class T> class Node { private: Node *_left; T _data; Node *_rigt; bool _color; // Color of link from parent. _color _data _left _rigt // ========= isred ========= // Post: Returns false if == nullptr. // Oterwise returns true if node is RED. template<class T> bool Node<T>::isRed(Node<T> *) { return == nullptr? BLACK : ->_color; }

23 // ========= Constructors ========= template<class T> <T>::() { _root = nullptr; // Te empty tree. } template<class T> Node<T>::Node(T data) : _color(red), _data(data), _left(nullptr), _rigt(nullptr) { } 50

24 Te rotate left operation 50 p < 50 > 60 > 50 < 60 (a) Before rotate left. > 60 < 50 > 50 < 60 (b) After rotate left. Te black eigt and te order are maintained.

25 // ========= rotateleft ========= // Pre: ->_rigt is RED. // Post: is rotated left. // Post: A pointer p to te root node of te modified tree is returned. // Post: p->left is RED. template<class T> Node<T> *Node<T>::rotateLeft(Node<T> *) { Node<T> *p = ->_rigt; ->_rigt = p->_left; p->_left = ; p->_color = ->_color; ->_color = RED; return p; }

26 p p 60 < 50 < 50 > 50 < 50 < 60 > 60 > 50 < 60 > 60 > 50 < 60 > 60 (a) Initial tree. (b) p = ->_rigt (c) ->_rigt = p->_left p 60 p 60 p > 60 > 60 > 60 < 50 > 50 < 60 (d) p->_left = < 50 > 50 < 60 (e) p->_color = ->_color < 50 > 50 < 60 (f) ->_color = RED

27 Te rotate rigt operation 60 p > 60 < 50 < 50 > 50 < 60 (a) Before rotate rigt. > 50 < 60 (b) After rotate rigt. > 60 Te black eigt and te order are maintained.

28 // ========= rotaterigt ========= // Pre: ->_left is RED. // Post: is rotated rigt. // Post: A pointer p to te root node of te modified tree is returned. // Post: p->rigt is RED. template<class T> Node<T> *Node<T>::rotateRigt(Node<T> *) { cerr << rotaterigt(): Exercise for te student. << endl; trow -1; }

29 Te flip colors operation (a) Before flip colors. (b) After flip colors. Te black eigt is maintained if is black and ->_left and ->_rigt are bot red.

30 // ========= flipcolors ========= // Pre: as nonempty _left and _rigt. // Post: Te colors of and its cildren are flipped. template<class T> void Node<T>::flipColors(Node<T> *) { ->_color =!->_color; cerr << flipcolors(): Exercise for te student. << endl; trow -1; }

31 Inserting into

32 // ========= insert ========= // Post: data is stored in tis tree in order wit no duplicates. template<class T> void <T>::insert(T const &data) { _root = _root->insert(_root, data); _root->_color = BLACK; } // Post: val is stored in root node in order as a leaf. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::insert(Node<T> *, T const &data) { if ( == nullptr) { return new Node<T>(data); } if (data < ->_data) { ->_left = insert(->_left, data); } else if (data > ->_data) { ->_rigt = insert(->_rigt, data); } // else no duplicates. return fixup(); }

33 Capter 10 Before calling fixup(), wic properties migt be violated? Ared-black tree is a binary searc tree. Every link is eiter red or black. Every cild tat is an empty tree is a leaf wit a black link to its parent. No pat from te root to any leaf as two red links in a row. All pats from eac node to all its leaves ave te same number of black links. A left-leaning red-black tree is a red-black tree. Every red link is to a left cild.

34 Capter 10 Before calling fixup(), wic properties migt be violated? Ared-black tree is a binary searc tree. Every link is eiter red or black. Every cild tat is an empty tree is a leaf wit a black link to its parent. No pat from te root to any leaf as two red links in a row. All pats from eac node to all its leaves ave te same number of black links. A left-leaning red-black tree is a red-black tree. Every red link is to a left cild.

35 Capter 10 Te purpose of fixup() is to correct two possible problems. Te additional red link migt be to a rigt cild. Te additional red link migt produce two red links in a row.

36 Capter 10 fixup() makes tree adjustments. If te red link is a rigt link, make it a left link. If tere are two red left links in a row, rotate rigt in preparation for te last adjustment. If te left and rigt links are bot red, flip colors.

37 // ========= fixup ========= // Pre: ->_left and ->_rigt are roots of left-leaning red-black trees. // Post: is a root of a left-leaning red-black tree. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::fixup(Node<T> *) { if (isred(->_rigt)) { = rotateleft(); } if (isred(->_left) && isred(->_left->_left)) { = rotaterigt(); } if (isred(->_left) && isred(->_rigt)) { flipcolors(); } return ; }

38 Inserting as a rigt leaf wit a black sibling (a) Initial tree. (b) Insert 60. (c) Rotate left.

39 Inserting as a left leaf wit a red parent (a) Initial tree. (b) Insert 60. (c) No fixup (d) Rotate rigt. (e) Flip colors.

40 Inserting as a rigt leaf wit a red sibling (a) Initial tree. (b) Insert 60. (c) Rotate left (d) Rotate rigt. (e) Flip colors.

41 Inserting 50 into

42 (a) Initial tree. (b) ->rigt = insert(->rigt, data) (c) = rotateleft() (d) = rotaterigt()

43 (e) flipcolors() (f) = rotateleft()

44 Deleting from

45 Capter 10 Te remove operation Find te node to remove. Find te minimum of te rigt cild of te node to remove, wic is te successor node. Copy te data from te successor to te node to remove wit te min() operation. Remove te minimum of te rigt cild.

46 Capter 10 Te remove operation Find te node to remove. Find te minimum of te rigt cild of te node to remove, wic is te successor node. Copy te data from te successor to te node to remove wit te min() operation. Remove te minimum of te rigt cild.

47 Capter 10 Useful fact Te minimum of a as a left cild. Terefore, it must ave a rigt cild. - Te rigt cild cannot be red because te tree is left-leaning. - If te rigt cild were not, te successor would not ave a unique black eigt. Conclusion: We do not need a remroot operation! We can simply delete te successor.

48 Capter 10 Delete minimum strategy If te node to be deleted as a red link to it, te node can be deleted witout affecting te black eigt requirement. Problem: Te node to be deleted migt ave a black link to it. Solution: Pus red links down on te way to te minimum, wic creates rigt-leaning reds. Fix te rigt-leaning reds on te way up.

49 Capter 10 Te moveredleft operation Te purpose of te moveredleft operation is to pus te red links down on te way to te minimum to guarantee tat te minimum will be connected to its parent wit a red link. It is only called on te way down if tere are two left black links in a row.

50 Guaranteed to ave red link from parent.

51 Called on te way down if two left black links in a row

52 Recursively move down te left to find te minimum.

53 Same fixup as wit insert!

54 // ========= moveredleft ========= // Pre: as nonempty _left and _rigt. // Invariant: Eiter or ->_left is RED. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::moveRedLeft(Node<T> *) { flipcolors(); Move red left migt only flip te colors. if (isred(->_rigt->_left)) { ->_rigt = rotaterigt(->_rigt); = rotateleft(); flipcolors(); } return ; }

55 // ========= moveredleft ========= // Pre: as nonempty _left and _rigt. // Invariant: Eiter or ->_left is RED. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::moveRedLeft(Node<T> *) { } flipcolors(); if (isred(->_rigt->_left)) { ->_rigt = rotaterigt(->_rigt); = rotateleft(); flipcolors(); } return ; Tis condition could not be repaired by fixup on te way back up.

56 Deleting minimum. Move red left only flips colors l r l r (a) Initial tree (b) moveredleft() only flips colors

57 Deleting minimum. Move red left only flips colors l r l r (c) moveredleft() only flips colors (d) moveredleft() only flips colors.

58 Deleting minimum. Move red left only flips colors l r l r (e) Delete minimum wit red parent link. (f) Fixup wit rotateleft().

59 Deleting minimum. Move red left only flips colors r l l r (g) Fixup wit rotateleft(). 20 () Fixup wit rotateleft().

60 Deleting minimum. Move red left does more tan flipping colors l r l r (a) Initial tree. (b) moveredleft() only flips colors.

61 Deleting minimum. Move red left does more tan flipping colors l r l r (c) First, moveredleft() flips colors. (d) ->_rigt = rotaterigt(->_rigt).

62 Deleting minimum. Move red left does more tan flipping colors l r l r (e) = rotateleft(). (f) = flipcolors().

63 Deleting minimum. Move red left does more tan flipping colors l r l r (g) moveredleft() is not called () moveredleft() only flips colors.

64 Deleting minimum. Move red left does more tan flipping colors l r l r (i) Delete minimum wit red parent link. (j) After four fixups.

65 Capter 10 Te remove operation Find te node to remove. Find te minimum of te rigt cild of te node to remove, wic is te successor node. Copy te data from te successor to te node to remove wit te min() operation. Remove te minimum of te rigt cild.

66 Used to copy te data from te successor node. // ========= min ========= // Pre:!= nullptr. // Post: Te minimum of tree rooted at is returned. template<class T> T Node<T>::min(Node<T> *) { Node<T> *p = ->_left; cerr << min(): Exercise for te student. << endl; trow -1; }

67 Capter 10 Te remove operation Find te node to remove. Find te minimum of te rigt cild of te node to remove, wic is te successor node. Copy te data from te successor to te node to remove wit te min() operation. Remove te minimum of te rigt cild.

68 Capter 10 Find te node to remove Same strategy: need to pus te red links down. Finding te node to remove may require moving to te rigt as well as to te left. If you move to te left on te way to te node to remove, call moveredleft() as before. If you move to te rigt, call moveredrigt().

69 // ========= moveredrigt ========= // Pre: as nonempty _left and _rigt. // Invariant: Eiter or ->_rigt is RED. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::moveRedRigt(Node<T> *) { flipcolors(); Move red rigt migt only flip te colors. if (isred(->_left->_left)) { = rotaterigt(); flipcolors(); } return ; }

70 // ========= moveredrigt ========= // Pre: as nonempty _left and _rigt. // Invariant: Eiter or ->_rigt is RED. // Post: A pointer to te root node of te modified tree is returned. template<class T> Node<T> *Node<T>::moveRedRigt(Node<T> *) { } flipcolors(); if (isred(->_left->_left)) { = rotaterigt(); flipcolors(); } return ; Tis condition could not be repaired by fixup on te way back up.

71 Te remove operation // ========= remove ========= // Pre: Tis tree contains data. // Post: data is removed from tis tree. template<class T> void <T>::remove(T const &data) { _root = _root->remove(_root, data); if (_root!= nullptr) { _root->_color = BLACK; } }

72 Move down to te left.

73 Found, or move down to te rigt.

74 Adjust left red link to rigt.

75 Found and can return immediately.

76 Possible adjustment wit moveredrigt.

77 Found te node to remove.

78 Copy data from successor node.

79 Delete successor node.

80 Move down to te rigt.

81

82 Insert fixup, general red-black tree RB-INSERT-FIXUP.T; / Capter 11 wile :p:color == RED if :p == :p:p:left y D :p:p:rigt if y:color == RED :p:color D BLACK y:color D BLACK Case 1 :p:p:color D RED D :p:p else if == :p:rigt D :p LEFT-ROTATE.T; / Case 2 :p:color D BLACK :p:p:color D RED Case 3 RIGHT-ROTATE.T; :p:p/ else (same as ten clause wit rigt and left excanged) T:root:color D BLACK

83 Remove fixup, general red-black tree RB-DELETE-FIXUP.T; x/ wile x T:root and x:color == BLACK if x == x:p:left w D x:p:rigt if w:color == RED w:color D BLACK Cap x:p:color D RED LEFT-ROTATE.T; x:p/ w D x:p:rigt if w:left:color == BLACK and w:rigt:color == BLACK w:color D RED x D x:p else if w:rigt:color == BLACK w:left:color D BLACK w:color D RED RIGHT-ROTATE.T; w/ w D x:p:rigt w:color D x:p:color x:p:color D BLACK w:rigt:color D BLACK LEFT-ROTATE.T; x:p/ x D T:root Case 1 Case 2 Case 3 Case 4 else (same as ten clause wit rigt and left excanged) x:color D BLACK