Balanced Trees Part One

Transcription

1 Balanced Trees Part One

2 Balanced Trees Balanced search trees are among the most useful and versatile data structures. Many programming languages ship with a balanced tree library. C++: std::map / std::set Java: TreeMap / TreeSet Python: OrderedDict Many advanced data structures are layered on top of balanced trees. We'll see them used to build y-fast Tries later in the quarter. (They re really cool, trust me!)

3 Where We're Going B-Trees A simple type of balanced tree developed for block storage. Red/Black Trees The canonical balanced binary search tree. Augmented Search Trees Adding extra information to balanced trees to supercharge the data structure. Two Advanced Operations The split and join operations.

4 Outline for Today BST Review Refresher on basic BST concepts and runtimes. Overview of Red/Black Trees What we're building toward. B-Trees and Trees A simple balanced tree in depth. Intuiting Red/Black Trees A much better feel for red/black trees.

5 A Quick BST Review

6 Binary Search Trees A binary search tree is a binary tree with the following properties: Each node in the BST stores a key, and optionally, some auxiliary information. The key of every node in a BST is strictly greater than all keys to its left and strictly smaller than all keys to its right. The height of a binary search tree is the length of the longest path from the root to a leaf, measured in the number of edges. A tree with one node has height 0. A tree with no nodes has height -1, by convention.

7 Searching a BST

8 Searching a BST

9 Searching a BST

10 Searching a BST

11 Searching a BST

12 Searching a BST

13 Searching a BST

14 Searching a BST

15 Searching a BST

16 Searching a BST

17 Inserting into a BST

18 Inserting into a BST

19 Inserting into a BST

20 Inserting into a BST

21 Inserting into a BST

22 Inserting into a BST

23 Inserting into a BST

24 Inserting into a BST

25 Deleting from a BST

26 Deleting from a BST

27 Deleting from a BST

28 Deleting from a BST

29 Deleting from a BST

30 Deleting from a BST

31 Deleting from a BST

32 Deleting from a BST Case Case 1: 1: If If the the node node has has just just no no children, children, just just remove remove it. it. 166

33 Deleting from a BST

34 Deleting from a BST

35 Deleting from a BST

36 Deleting from a BST

37 Deleting from a BST

38 Deleting from a BST Case Case 2: 2: If If the the node node has has just just one one child, child, remove remove it it and and replace replace it it with with its its child. child

39 Deleting from a BST

40 Deleting from a BST

41 Deleting from a BST

42 Deleting from a BST

43 Deleting from a BST

44 Deleting from a BST

45 Deleting from a BST

46 Deleting from a BST

47 Deleting from a BST

48 Deleting from a BST

49 Deleting from a BST

50 Deleting from a BST Case Case 3: 3: If If the the node node has has two two children, children, fnd fnd its its inorder inorder successor successor (which (which has has zero zero or or one one child), child), replace replace the the node's node's key key with with its its successor's successor's key, key, then then delete delete its its successor. successor

51 Runtime Analysis The time complexity of all these operations is O(h), where h is the height of the tree. Represents the longest path we can take. In the best case, h = O(log n) and all operations take time O(log n). In the worst case, h = Θ(n) and some operations will take time Θ(n). Challenge: How do you eficiently keep the height of a tree low?

52 A Glimpse of Red/Black Trees

53 Red/Black Trees A red/black tree is a BST with the following properties: 110 Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

54 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

55 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

56 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

57 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

58 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

59 Red/Black Trees Theorem: Any red/black tree with n nodes has height O(log n). We could prove this now, but there's a much simpler proof of this we'll see later on. Given a fxed red/black tree, lookups can be done in time O(log n).

60 Mutating Red/Black Trees

61 Mutating Red/Black Trees

62 Mutating Red/Black Trees

63 Mutating Red/Black Trees

64 Mutating Red/Black Trees

65 Mutating Red/Black Trees

66 Mutating Red/Black Trees

67 Mutating Red/Black Trees

68 Mutating Red/Black Trees What What are are we we supposed supposed to to do do with with this this new new node? node?

69 Mutating Red/Black Trees

70 Mutating Red/Black Trees

71 Mutating Red/Black Trees

72 Mutating Red/Black Trees

73 Mutating Red/Black Trees

74 Mutating Red/Black Trees

75 Mutating Red/Black Trees

76 Mutating Red/Black Trees How How do do we we fx fx up up the the black-height property? property?

77 Fixing Up Red/Black Trees The Good News: After doing an insertion or deletion, can locally modify a red/black tree in time O(log n) to fx up the red/black properties. The Bad News: There are a lot of cases to consider and they're not trivial. Some questions: How do you memorize / remember all the diferent types of rotations? How on earth did anyone come up with red/black trees in the frst place?

78 B-Trees

79 Generalizing BSTs In a binary search tree, each node stores a single key. That key splits the key space into two pieces, and each subtree stores the keys in those halves Values less than two Values greater than two

80 Generalizing BSTs In a multiway search tree, each node stores an arbitrary number of keys in sorted order In a node with k keys splits the key space into k + 1 pieces, and each subtree stores the keys in those pieces.

81 One Solution: B-Trees A B-tree of order b is a multiway search tree with the following properties: All leaf nodes are stored at the same depth. All non-root nodes have between b 1 and 2b 1 keys. The root node has been 1 and 2b 1 keys. All root-null paths through the tree pass through the same number of nodes. 43 B-tree B-tree of of order order

82 One Solution: B-Trees A B-tree of order b is a multiway search tree with the following properties: All leaf nodes are stored at the same depth. All non-root nodes have between b 1 and 2b 1 keys. The root node has been 1 and 2b 1 keys. All root-null paths through the tree pass through the same number of nodes B-tree B-tree of of order order

83 2-3-4 Trees A tree is a B-tree of order 2. The rules for trees are really simple: All leaf nodes are stored at the same depth. All nodes have between 1 and 3 keys (between 2 and 4 children). All root-null paths through the tree pass through the same number of nodes. These fellas will make a number of appearances later on. Stay tuned!

84 The Tradeof Because B-tree nodes can have multiple keys, when performing a search, insertion, or deletion, we have to spend more work inside each node. Insertion and deletion can be expensive for large b, we might have to shufe thousands or millions of keys over! Why would you use a B-tree?

85 Memory Tradeofs There is an enormous tradeof between speed and size in memory. SRAM (the stuf registers are made of) is fast but very expensive: Can keep up with processor speeds in the GHz. As of 2010, cost is $5/MB. (Anyone know a good source for a more recent price?) Good luck buying 1TB of the stuf! Hard disks are cheap but very slow: As of 2018, you can buy a 4TB hard drive for about $100. As of 2018, good disk seek times for magnetic drives are measured in ms (about two to four million times slower than a processor cycle!)

86 The Memory Hierarchy Idea: Try to get the best of all worlds by using multiple types of memory.

87 The Memory Hierarchy Idea: Try to get the best of all worlds by using multiple types of memory. Registers L1 Cache L2 Cache Main Memory Hard Disk Network (The Cloud) 256B - 8KB 16KB 64KB 1MB - 4MB 4GB 256GB 1TB+ Lots ns 1ns 5ns 5ns 25ns 25ns 100ns 3 10ms ms

88 Why B-Trees? Because B-trees have a huge branching factor, they're great for on-disk storage. Disk block reads/writes are glacially slow. The high branching factor minimizes the number of blocks to read during a lookup. Extra work scanning inside a block ofset by these savings. Major use cases for B-trees and their variants (B +-trees, H-trees, etc.) include databases (huge amount of data stored on disk); file systems (ext4, N4T,S, Re,S); and, recently, in-memory data structures (due to cache efects).

89 The Height of a B-Tree What is the maximum possible height of a B-tree of order b? 1 1 b 1 b 1 2(b - 1) b 1 b 1 b 1 b 1 2b(b - 1) b 1 b 1 b 1 b 1 2b 2 (b - 1) b 1 b 1 b 1 2b h-1 (b - 1)

90 The Height of a B-Tree Theorem: The maximum height of a B-tree of order b containing n nodes is log b ((n + 1) / 2). Proof: N4umber of nodes n in a B-tree of height h is guaranteed to be at least = 1 + 2(b 1) + 2b(b 1) + 2b 2 (b 1) + + 2b h-1 (b 1) = 1 + 2(b 1)(1 + b + b b h-1 ) = 1 + 2(b 1)((b h 1) / (b 1)) = 1 + 2(b h 1) = 2b h 1. Solving n = 2b h 1 yields h = log b ((n + 1) / 2). Corollary: B-trees of order b have height Θ(logb n).

91 Searching in a B-Tree Doing a search in a B-tree involves searching the root node for the key, and if it's not found, recursively exploring the correct child. Using binary search within a given node, can find the key or the correct child in time O(log number-of-keys). Repeat this process O(tree-height) times. Time complexity is = O(log number-of-keys tree-height) = O(log b log b n) = O(log b (log n / log b)) = O(log n) Requires reading O(logb n) blocks; this more directly accounts for the total runtime.

92 Searching in a B-Tree Doing a search in a B-tree involves searching the root node for the key, and if it's not found, recursively exploring the correct child. Using binary search within a given node, can find the key or the correct child in time O(log number-of-keys). Repeat this process O(tree-height) times. Time complexity is = O(log number-of-keys tree-height) = O(log b log b n) = O(log b (log n / log b)) = O(log n) Requires reading O(logb n) blocks; this more directly accounts for the total runtime.

93 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

94 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

95 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

96 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

97 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

98 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

99 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

100 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

101 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

102 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

103 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

104 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

105 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

106 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

107 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

108 B-Trees are Simple Because nodes in a B-tree can store multiple keys, most insertions or deletions are straightforward. Here's a B-tree with b = 3 (nodes have between 2 and 5 keys):

109 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

110 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

111 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

112 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

113 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

114 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

115 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

116 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

117 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

118 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

119 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

120 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys)

121 The Trickier Cases What happens if you insert a key into a node that's too full? Idea: Split the node in two and propagate upward. Here's a tree (each node has 1 to 3 keys). 41 Note: Note: B-trees B-trees grow grow upward, upward, not not downward. downward

122 Inserting into a B-Tree To insert a key into a B-tree: Search for the key, insert at the last-visited leaf node. If the leaf is too big (contains 2b keys): Split the node into two nodes of size b each. Remove the largest key of the first block and make it the parent of both blocks. Recursively add that node to the parent, possibly triggering more upward splitting. Time complexity: O(b) work per level and O(logb n) levels. Total work: O(b logb n) In terms of blocks read: O(logb n)

123 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

124 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

125 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

126 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

127 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

128 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

129 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

130 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

131 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

132 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

133 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

134 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

135 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

136 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

137 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

138 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

139 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

140 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

141 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

142 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

143 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

144 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

145 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

146 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

147 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

148 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

149 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

150 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

151 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

152 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree: 46?

153 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:?

154 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:?

155 The Trickier Cases How do you delete from a leaf that has only b 1 keys? Idea: Steal keys from an adjacent nodes, or merge the nodes if both are empty. Again, a tree:

156 Deleting from a B-Tree If not in a leaf, replace the key with its successor from a leaf and delete out of a leaf. To delete a key from a node: If the node has more than b 1 keys, or if the node is the root, just remove the key. Otherwise, find a sibling node whose shared parent is p. If that sibling has more than b 1 keys, move the max/min key from that sibling into p's place and p down into the current node, then remove the key. Otherwise, fuse the node and its sibling into a single node by adding p into the block, then recursively remove p from the parent node. Work done is O(b log b n): O(b) work per level times O(log b n) total levels. Requires O(log b n) block reads/writes.

157 Time-Out for Announcements!

158 Problem Sets Problem Set One solutions are now available up on the course website. We re working on getting them graded stay tuned! Problem Set Two is due next Tuesday. Have questions? Ask them on Piazza or stop by our ofice hours!

159 Back to CS166!

160 So... red/black trees?

161 Red/Black Trees A red/black tree is a BST with the following properties: 110 Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

162 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black No red node has a red child. Every root-null path in the tree passes through the same number of black nodes.

163 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black. No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

164 Red/Black Trees A red/black tree is a BST with the following properties: Every node is either red or black. The root is black. No red node has a red child. Every root-null path in the tree passes through the same number of black nodes

165 Data Structure Isometries Red/black trees are an isometry of trees; they represent the structure of trees in a diferent way. Many data structures can be designed and analyzed in the same way. Huge advantage: Rather than memorizing a complex list of red/black tree rules, just think about what the equivalent operation on the corresponding tree would be and simulate it with color fips and rotations.

166 The Height of a Red/Black Tree Theorem: Any red/black tree with n nodes has height O(log n). Proof: Contract all red nodes into their parent nodes to convert the red/black tree into a tree. This decreases the height of the tree by at most a factor of two. The resulting tree has height O(log n), so the original red/black tree has height 2 O(log n) = O(log n).

167 Exploring the Isometry Nodes in a tree are classifed into types based on the number of children they can have. 2-nodes have one key (two children). 3-nodes have two keys (three children). 4-nodes have three keys (four children). How might these nodes be represented?

168 Exploring the Isometry k₁ k₁ k₁ k₂ k₁ k₂ k₂ k₁ k₂ k₁ k₂ k₃ k₁ k₃

169 Using the Isometry

170 Using the Isometry

171 Using the Isometry

172 Using the Isometry

173 Using the Isometry

174 Using the Isometry

175 Using the Isometry

176 Using the Isometry

177 Using the Isometry

178 Using the Isometry

179 Using the Isometry

180 Using the Isometry

181 Using the Isometry

182 Using the Isometry

183 Using the Isometry

184 Using the Isometry

185 Using the Isometry

186 Using the Isometry

187 Using the Isometry

188 Using the Isometry

189 Using the Isometry

190 Red/Black Tree Insertion Rule #1: When inserting a node, if its parent is black, make the node red and stop. Justifcation: This simulates inserting a key into an existing 2-node or 3-node.

191 Using the Isometry

192 Using the Isometry

193 Using the Isometry

194 Using the Isometry

195 Using the Isometry

196 Using the Isometry

197 Using the Isometry

198 Using the Isometry

199 Using the Isometry

200 Using the Isometry

201 Using the Isometry

202 Using the Isometry We We need need to to Change Change the the colors colors of of the the nodes, nodes, and and Move Move the the nodes nodes around around in in the the tree. tree.

203 Tree Rotations B Rotate Right A Rotate Left A B >B <A <A >A <B >A <B >B

204 3 apply rotation This This applies applies any any time time we're we're inserting inserting a new new node node into into the the middle middle of of a 3-node. 3-node. 5 4 By By making making observations observations like like these, these, we we can can determine determine how how to to update update a red/black red/black tree tree after after an an insertion. insertion. 4 apply rotation 3 5 change colors 3 5

205 Using the Isometry

206 Using the Isometry

207 Using the Isometry

208 Using the Isometry

209 Using the Isometry

210 Using the Isometry

211 Using the Isometry

212 Using the Isometry

213 Using the Isometry

214 Using the Isometry

215 Using the Isometry

216 Using the Isometry

217 Using the Isometry

218 Using the Isometry

219 Using the Isometry

220 Using the Isometry

221 Using the Isometry

222 Using the Isometry

223 Using the Isometry

224 Using the Isometry Two Two steps: steps: Split Split the the 5-node 5-node into into a 2-node 2-node and and a 3-node. 3-node Insert Insert the the new new parent parent of of the the two two nodes nodes into into the the parent parent node. node.

225 change colors

226 Using the Isometry

227 Using the Isometry

228 Using the Isometry

229 Using the Isometry

230 Using the Isometry

231 Using the Isometry

232 Using the Isometry

233 Using the Isometry

234 Building Up Rules All of the crazy insertion rules on red/black trees make perfect sense if you connect it back to trees. There are lots of cases to consider because there are many diferent ways you can insert into a red/black tree. Main point: Simulating the insertion of a key into a node takes time O(1) in all cases. Therefore, since trees support O(log n) insertions, red/black trees support O(log n) insertions. The same is true of deletions.

235 My Advice Do know how to do B-tree insertions and deletions. You can derive these easily if you remember to split and join nodes. Do remember the rules for red/black trees and B-trees. These are useful for proving bounds and deriving results. Do remember the isometry between red/black trees and trees. Gives immediate intuition for all the red/black tree operations. Don't memorize the red/black rotations and color fips. This is rarely useful. If you're coding up a red/black tree, just fip open CLRS and translate the pseudocode.

236 Next Time Augmented Trees Building data structures on top of balanced BSTs. Splitting and Joining Trees Two powerful operations on balanced trees.