Upload
emory-flynn
View
216
Download
0
Embed Size (px)
DESCRIPTION
Rudolf Bayer He has been a Professor of informatics at the Technical University of Munich since –Informatics is a science concerned with collection, classification, manipulation, storage, retrieval and dissemination of information. He if famous for inventing 2 sorting structures, B-trees (now called red black trees), with Edward M. McCreight. And UB-tress (with Volker Markl). –UB-Trees is another type of balanced tree used for storing and for efficiently retrieving multidimensional data.
Citation preview
Red Black Trees
History• The concept of a balancing tree was first invented by
Adel’son-Vel’skii and Landis in 1962. They came up with the AVL tree.
• In 1970, J. E. Hopcroft invented the 2-3 trees (another balancing Search Tree.
• The Red Black Tree was first invented by Rudolf Bayer (1972), who called them “symmetric binary B-trees”.
• In 1978, Leo J Guibas and Robert Sedgewick came up with the term, Red Black Binary Tree.
Rudolf Bayer• He has been a Professor of informatics at the Technical
University of Munich since 1972.– Informatics is a science concerned with collection,
classification, manipulation, storage, retrieval and dissemination of information.
• He if famous for inventing 2 sorting structures, B-trees (now called red black trees), with Edward M. McCreight. And UB-tress (with Volker Markl). – UB-Trees is another type of balanced tree used for
storing and for efficiently retrieving multidimensional data.
4
Red-Black Trees• “Balanced” binary trees guarantee an O(lgn) running
time on the basic dynamic-set operations• Red-black-tree
– Binary tree with an additional attribute for its nodes: color which can be red or black
– Constrains the way nodes can be colored on any path from the root to a leaf
• Ensures that no path is more than twice as long as another the tree is balanced
– The nodes inherit all the other attributes from the binary-search trees: key, left, right, p
Red-Black Trees (RBT) Red-Black tree: BST in which each node is colored red or
black.Constraints on the coloring and connection of nodes
ensure thatno root to leaf path is more than twice as long as any
other, sotree is approximately balanced.Each RBT node contains fields left, right, parent, color, and
key.LEFT
PARENT RIGHT
KEYCOLOR
6
Red-Black-Trees Properties
1. Every node is either red or black2. The root is black3. Every leaf (NIL) is black4. If a node is red, then both its children are black
• No two red nodes in a row on a simple path from the root to a leaf
5. For each node, all paths from the node to descendant leaves contain the same number of black nodes
7
Example: RED-BLACK-TREE
• For convenience we use a sentinel NIL[T] to represent all the NIL nodes at the leafs– NIL[T] has the same fields as an ordinary node– Color[NIL[T]] = BLACK– The other fields may be set to arbitrary values
26
17 41
30 47
38 50
NIL NIL
NIL
NIL NIL NIL NIL
NIL
8
Black-Height of a Node
• Height of a node: the number of edges in a longest path to a leaf
• Black-height of a node x: bh(x) is the number of black nodes (including NIL) on the path from x to leaf, not counting x
26
17 41
30 47
38 50
NIL NIL
NIL
NIL NIL NIL NIL
NIL
h = 4bh = 2
h = 3bh = 2
h = 2bh = 1
h = 1bh = 1
h = 1bh = 1
h = 2bh = 1 h = 1
bh = 1
9
Properties of Red-Black-Trees• Claim
– Any node with height h has black-height ≥ h/2• Proof
– By property 4, at most h/2 red nodes on the path from the node to a leaf
– Hence at least h/2 are black26
17 41
30 47
38 50
Property 4: if a node is red then both its children are black
10
Properties of Red-Black-TreesClaim
– The subtree rooted at any node x contains at least 2bh(x) - 1 internal nodes
Proof: By induction on height of xBasis: height[x] = 0
x is a leaf (NIL[T])
bh(x) = 0
# of internal nodes: 20 - 1 = 0
NIL
x
11
Properties of Red-Black-TreesInductive step: • Let height(x) = h and bh(x) = b• Any child y of x has:
– bh (y) =– bh (y) =
26
17 41
30 47
38 50
b (if the child is red), orb - 1 (if the child is black)
12
Properties of Red-Black-Trees• Want to prove:
– The subtree rooted at any node x contains at least 2bh(x) - 1 internal nodes
• Internal nodes for each child of x:
2bh(x) - 1 - 1• The subtree rooted at x contains at least:
(2bh(x) - 1 – 1) + (2bh(x) - 1 – 1) + 1 = 2 · (2bh(x) - 1 - 1) + 1 = 2bh(x) - 1 internal nodes
x
l r
13
Properties of Red-Black-TreesLemma: A red-black tree with n internal nodes has height
at most 2lg(n + 1).Proof:
n
• Add 1 to both sides and then take logs: n + 1 ≥ 2b ≥ 2h/2
lg(n + 1) ≥ h/2 h ≤ 2 lg(n + 1)
root
l r
height(root) = hbh(root) = b
number n of internal nodes
≥ 2b - 1 ≥ 2h/2 - 1since b h/2
14
Operations on Red-Black-Trees• The non-modifying binary-search-tree operations
MINIMUM, MAXIMUM, SUCCESSOR, PREDECESSOR,
and SEARCH run in O(h) time
– They take O(lgn) time on red-black trees
• What about TREE-INSERT and TREE-DELETE?
– They will still run on O(lgn) – We have to guarantee that the modified tree will still be
a red-black tree
15
INSERTINSERT: what color to make the new node?• Red? Let’s insert 35!
– Property 4: if a node is red, then both its children are black
• Black? Let’s insert 14!– Property 5: all paths from a node to its leaves contain
the same number of black nodes26
17 41
30 47
38 50
16
DELETEDELETE: what color was the node that was removed? Red? 1. Every node is either red or black2. The root is black3. Every leaf (NIL) is black4. If a node is red, then both its children are black
5. For each node, all paths from the node to descendant leaves contain the same number of black nodes
OK!OK!OK!
OK! Does not createtwo red nodes in a rowOK! Does not change
any black heights
26
17 41
30 47
38 50
17
DELETEDELETE: what color was the node that was removed? Black? 1. Every node is either red or black2. The root is black3. Every leaf (NIL) is black4. If a node is red, then both its children are black
5. For each node, all paths from the node to descendant leaves contain the same number of black nodes
OK!
OK!
Not OK! Could createtwo red nodes in a row
Not OK! Could change theblack heights of some nodes
26
17 41
30 47
38 50
Not OK! If removing the root and the child that replaces it is red
18
Rotations• Operations for restructuring the tree after insert and delete
operations on red-black trees
• Rotations take a red-black-tree and a node within the tree and:
– Together with some node re-coloring they help restore the red-black-tree property
– Change some of the pointer structure
– Do not change the binary-search tree property
• Two types of rotations:
– Left & right rotations
19
Left Rotations• Assumptions for a left rotation on a node x:
– The right child of x (y) is not NIL– Root’s parent is NIL
• Idea:– Pivots around the link from x to y– Makes y the new root of the subtree– x becomes y’s left child– y’s left child becomes x’s right child
20
LEFT-ROTATE(T, x)1. y ← right[x] ►Set y2. right[x] ← left[y] ► y’s left subtree becomes x’s right subtree3. if left[y] NIL4. then p[left[y]] ← x ► Set the parent relation from left[y] to x5. p[y] ← p[x] ► The parent of x becomes the parent of y6. if p[x] = NIL7. then root[T] ← y8. else if x = left[p[x]]9. then left[p[x]] ← y10. else right[p[x]] ← y11. left[y] ← x ► Put x on y’s left12. p[x] ← y ► y becomes x’s parent
21
Example: LEFT-ROTATE
22
Right Rotations• Assumptions for a right rotation on a node x:
– The left child of y (x) is not NIL– Root’s parent is NIL
• Idea:– Pivots around the link from y to x– Makes x the new root of the subtree– y becomes x’s right child– x’s right child becomes y’s left child
23
Insertion
• Goal:
– Insert a new node z into a red-black-tree
• Idea:
– Insert node z into the tree as for an ordinary binary
search tree
– Color the node red
– Restore the red-black-tree properties
• Use an auxiliary procedure RB-INSERT-FIXUP
24
RB-INSERT(T, z)1. y ← NIL2. x ← root[T]3. while x NIL4. do y ← x5. if key[z] < key[x]6. then x ← left[x]7. else x ← right[x]8. p[z] ← y
• Initialize nodes x and y• Throughout the algorithm y points
to the parent of x
• Go down the tree untilreaching a leaf• At that point y is theparent of the node to beinserted
• Sets the parent of z to be y
26
17 41
30 47
38 50
25
RB-INSERT(T, z)9. if y = NIL10. then root[T] ← z11. else if key[z] < key[y]12. then left[y] ← z13. else right[y] ← z14. left[z] ← NIL15. right[z] ← NIL16. color[z] ← RED17. RB-INSERT-FIXUP(T, z)
The tree was empty: set the new node to be the root
Otherwise, set z to be the left orright child of y, depending on whether the inserted node is smaller or larger than y’s key
Set the fields of the newly added node
Fix any inconsistencies that could havebeen introduced by adding this new rednode
26
17 41
30 47
38 50
26
RB Properties Affected by Insert1. Every node is either red or black2. The root is black3. Every leaf (NIL) is black4. If a node is red, then both its children are black
5. For each node, all paths
from the node to descendant
leaves contain the same number
of black nodes
OK!If z is the root not OKOK!
26
17 41
4738
50
If p(z) is red not OKz and p(z) are both redOK!
27
RB-INSERT-FIXUP – Case 1z’s “uncle” (y) is red
Idea: (z is a right child)
• p[p[z]] (z’s grandparent) must be
black: z and p[z] are both red
• Color p[z] black
• Color y black
• Color p[p[z]] red
– Push the “red” violation up the tree
• Make z = p[p[z]]
CS 477/677 28
RB-INSERT-FIXUP – Case 1z’s “uncle” (y) is red
Idea: (z is a left child)
• p[p[z]] (z’s grandparent) must be
black: z and p[z] are both red
• color[p[z]] black
• color[y] black
• color p[p[z]] red
• z = p[p[z]]– Push the “red” violation up the tree
Case1
29
RB-INSERT-FIXUP – Case 3Case 3: • z’s “uncle” (y) is black• z is a left child
Case 3
Idea:• color[p[z]] black • color[p[p[z]]] red• RIGHT-ROTATE(T, p[p[z]])• No longer have 2 reds in a row• p[z] is now black
Case3
30
RB-INSERT-FIXUP – Case 2Case 2: • z’s “uncle” (y) is black• z is a right childIdea:• z p[z]• LEFT-ROTATE(T, z) now z is a left child, and both z and p[z] are red case 3
Case 2 Case 3
Case2
31
RB-INSERT-FIXUP(T, z)1. while color[p[z]] = RED2. do if p[z] = left[p[p[z]]]3. then y ← right[p[p[z]]]4. if color[y] = RED5. then Case16. else if z = right[p[z]]7. then Case28. Case39. else (same as then clause with “right”
and “left” exchanged)10. color[root[T]] ← BLACK
The while loop repeats only whencase1 is executed: O(lgn) times
Set the value of x’s “uncle”
We just inserted the root, orThe red violation reached the root
32
Example11
Insert 4
2 14
1 157
85
4
y
11
2 14
1 157
85
4
z
Case 1
y
z and p[z] are both redz’s uncle y is redz
z and p[z] are both redz’s uncle y is blackz is a right child
Case 2
11
2
14
1
15
7
8
5
4
zy Case 3
z and p[z] are redz’s uncle y is blackz is a left child
112
141
15
7
85
4
z
33
Analysis of RB-INSERT
• Inserting the new element into the tree O(lgn)
• RB-INSERT-FIXUP
– The while loop repeats only if CASE 1 is executed
– The number of times the while loop can be executed
is O(lgn)
• Total running time of RB-INSERT: O(lgn)
DeletionDeletion from a Binary Search tree: IF the node to delete has 2 children, we find the successor
node, move it’s information into the node we want to delete, and remove the successor node.
ELSE we remove the node with the given value.
In either case, the node that is actually removed will have 1 or 0 children.
If it has a child, we set the child’s parent to the parent of the removed node. Else, if no children, we set the nil (leaf) to be the child of the parent of the removed node.
Deletion• Deletion from a red black tree, is similar to deletion for a binary
search tree, with a few exception:– Always set the parent of a deleted node, to be the parent of one
of the deleted nodes children.– Red black fix-up method called if removed node is black.
• After a deletion of a red node (no violations occur):– No black-heights have been affected.
• The simple path from any node to a leaf contain the same # of black nodes.
– No red nodes have been made adjacent (parent and child both red).
– Deleted node is not the root since the root is black.
Delete Con’t
• After Deletion of a Black node a restore function must be called to fix red-black properties that might be violated. There are 3 possible initial violations.– If deleted node was the root, a red child might now be the root, Violation
of property 2.– If both the parent of removed node, and a child of removed node are
red, we have a violation of property 4.– The removal of a black node can cause the black-height of one path to
be shorter (by 1), violating property 5.– We correct the problem of rule 5 by adding an extra “black” to the node
passed into the fix-up procedure. This leads to violations in rules 1 since this node is now neither red or black.
• The goal now is to move the extra black to the root of the tree, and then get rid of the extra black.
Chapter 13 P.37
13.4 Deletion• RB-DELETE(T,z)
1 if left[z] = nil[T] or right[z] = nil[T]2 then y ← z3 else y ← TREE-SUCCESSOR(z)4 if left[y] ≠ nil[T]5 then x ← left[y]6 else x ← right[y]7 p[x] ← p[y] 8 if p[y] = nil[T]
Chapter 13 P.38
9 then root[T] ← x10 else if y = left[p[y]]11 then left[p[y]] ← x12 else right[p[y]] ← x13 if y ≠ z14 then key[z] ← key[y]15 copy y’s satellite data into z16 if color[y] = BLACK17 then RB-DELETE-FIXUP(T, x)18 return y
Chapter 13 P.39
RB-DELETE-FIXUP(T, x)• RB-DELETE-FIXUP
1 while x ≠ root[T] and color[x] = BLACK2 do if x = left[p[x]]3 then w ← right[p[x]]4 if color[w] = RED5 then color[w] ← BLACK Case16 color[p[x]] = RED Case17 LEFT-ROTATE(T,p[x]) Case18 w ← right[p[x]] Case1
Chapter 13 P.40
9 if color[left[w]] = BLACK and color[right[w]= BLACK
10 then color[w] ← RED Case211 x ← p[x] Case212 else if color[right[w]] = BLACK 13 then color[left[w]] ← BLACK Case314 color[w] ← RED Case315 RIGHT-ROTATE(T,w) Case3 16 w ← right[p[x]] Case317 color[w] ← color[p[x]] Case4
Chapter 13 P.41
18 color[p[x]] ← BLACK Case419 color[right[w]] ← BLACK Case420 LEFT-ROTATE(T,p[x]) Case421 x ← root[T] Case422 else (same as then clause with “right”
and “left” exchanged)23 color[x] ← BLACK
Chapter 13 P.42
the case in the while loop of RB-DELETE-FIXUP
Chapter 13 P.43
44
65
50 80
10 60 70 90
62
Perform the following deletions, in the order specifiedDelete 90, Delete 80, Delete 70
45
65
50
10 60
80
62
Delete 90: Case 2
70
46
65
50
10 60
70
62
Delete 80: Case 0
47
Delete 70: Case 1, then Case 3, then Case 4
50
6510
60
62
+
50
6510
62 +
60
50
6210
60 65
after Case 1 after Case 3 after Case 4
48
Red-Black Trees - Summary• Operations on red-black-trees:
– SEARCH O(h)– PREDECESSOR O(h)– SUCCESOR O(h)– MINIMUM O(h)– MAXIMUM O(h)– INSERT O(h)– DELETE O(h)
• Red-black-trees guarantee that the height of the tree will be O(lgn)