CSC 263 Lecture 4. September 13, 2006

Transcription

1 S 263 Lecture 4 September 13, ugmenting Red-lack Trees 7.1 Introduction Suppose that ou are asked to implement an DT that is the same as a dictionar but has one additional operation: operation: SIZE(Set S): Returns the current size of the set If we tr to implement this procedure without additional data in the data structure, the worst case running time would be Θ(n) or worse. ut, if we add a size variable and increment it when we insert and decrement it when we delete, then the running time would be Θ(1). This is an eample of augmenting a data structure. 7.2 Method In this section we will look at three eamples of augmenting red-black trees to support new queries. n data structure can be augmented to provide additional functionalit beond the original DT. red-black tree b itself is not ver useful. ll ou can do is search the tree for a node with a certain ke value. To support more useful queries we need to have more structure. When augmenting data structures, the following four steps are useful: 1. Pick a data structure to start with. 2. Determine additional information that needs to be maintained. 3. heck that the additional information can be maintained during each of the original operations (and at what additional cost, if an). 4. Implement the new operations. 7.3 Eample 1 Let s sa we want to support the quer MIN(R), which returns the node with minimum ke-value in red-black tree R. 19

2 One solution is to traverse the tree starting at the root and going left until there is no left-child. This node must have the minimum ke-value. Since we might be traversing the height of the tree, this operation takes O(log n) time. lternativel, we can store a pointer to the minimum node as part of the data structure (at the root, for instance). Then, to do a quer MIN(R), all we have to do is return the pointer (R.min), which takes time O(1). The problem is that we might have to update the pointer whenever we perform INSERT or DELETE. INSERT(R, ): Insert as before, but if ke() < ke(r.min), then update R.min to point at. This adds O(1) to the running time, so its compleit remains O(log n). DELETE(R, ): Delete as before, but if = R.min, then update R.min: if was the minimum node, then it had no left child. Since it is a red-black tree, its right-child, if it has one, is red (otherwise propert 3 would be violated). This right-child is succ() and becomes the new minimum if it eists. If had no children, then the new minimum is the parent of. gain we add O(1) to the running time of DELETE so it still takes O(log n) in total. This is the best-case scenario. We support a new quer in O(1)-time without sacrificing the running times of the other operations. 7.4 Eample 2 Now we want to know not just the minimum node in the tree, but, for an in the tree, the minimum node in the subtree rooted at. We ll call this quer SUMIN(R,). To achieve this quer in time O(1), we ll store at each a pointer.min, to the minimum node in its subtree. gain, we ll have to modif INSERT and DELETE to maintain this information. INSERT(R, ): Insert as before, but, for each that is an ancestor of, if ke() < ke(.min), then update.min to point at. This adds O(log n) to the running time, so its compleit remains O(log n). DELETE(R, ): Delete as before, but, for each that is an ancestor of, if =.min, then update.min: if was the minimum node in a subtree, then it had no left child. Since it is a red-black tree, its right-child, if it has one, is red (otherwise propert 3 would be violated). This right-child is succ() and becomes the new minimum if it eists. If had no children, then the new minimum is the parent of. gain we add O(log n) to the running time of DELETE so it still takes O(log n) in total. Fi-up: The rotations (but not the recolorings) in the fi-up processes for INSERT and DELETE might affect the submins of certain nodes. onsider RotateRight(T, ) where is the left child of. The submin of will be in the subtree (or will be itself if is empt). This doesn t change after the rotation. The submin of, however, which used to be the same as s submin, is now in (or itself if is empt). So, we set SUMIN(R,) to if is empt, or to SUMIN(R, z), where z is the root of. It takes just constant time to reset SUMIN(R,), so rotations still take O(1). The modification for a left rotation are smmetric. 20

3 RotateRight(T, ) 7.5 Eample 3 We want to support the following queries: RNK(R,k): Given a ke k, what is its rank, i.e., its position among the elements in the red-black tree? SELET(R, r): Given a rank r, what is the ke with that rank? Eample: If R contains the ke-values 3,15,27,30,56, then RNK(R,15) = 2 and SELET(R,4) = 30. Here are three possibilities for implementation: 1. Use red-black trees without modification: Queries: Simpl carr out an inorder traversal of the tree, keeping track of the number of nodes visited, until the desired rank or ke is reached. This requires time Θ(n) in the worst case. Updates: No additional information needs to be maintained. Problem: Quer time is ver long and this method does not take advantage of the structure of the Red-lack tree. We want to be able to carr out both tpes of queries in onl Θ(log n) time. 2. ugment red-black trees so that each node has an additional field rank() that stores its rank in the tree. Queries: Similar to SERH, choosing path according to ke or rank field (depending on the tpe of quer). This requires time Θ(log n), just like SERH. Updates: arr out normal update procedure, then update the rank field of all affected nodes. This can take time Θ(n) in the worst case, since an insertion or deletion affects the rank of ever node with higher ke-value. Problem: We ve achieved the Θ(log n) quer time we wanted, but at the epense of the update time, which has gone from Θ(log n) to Θ(n). We would like all operations to have time at worst Θ(log n). 3. ugment red-black trees so that each node has an additional field size() that stores the number of nodes in the subtree rooted at (including itself). 21

4 Queries: We know that rank() = 1 + number of nodes that come before in the tree. RNK(R,k): Given ke k, perform SERH on k keeping track of current rank r (which starts out as 0): when going left, r remains unchanged; when going right let r := r + size(left()) + 1. When found such that ke() = k, output r + size(left()) + 1. Note that we did not deal with degenerate cases (such as when k does not belong to the tree), but it is eas to modif the algorithm to treat those cases. SELET(R,r): Given rank r, start at = R and work down, looking for a node such that r = size(left()) + 1 (return that node once it is found). If r < size(left()) + 1, then we know the node we are looking for is in the left subtree, so we go left without changing r. If r > size(left()) + 1, then we know the node we are looking for is in the right subtree, and that its relative rank in that tree is equal to r (size(left()) + 1), so we change r accordingl and go right. Once again, we did not deal with degenerate cases (such as when r is a rank that does not correspond to an node in the tree), but the are easil accomodated with small changes to the algorithm. Quer time: Θ(log n), as desired, since both algorithms are essentiall like SERH (tracing a single path down from the root). Updates: INSERT and DELETE operations consist of two phases for red-black trees: the operation itself, followed b the fi-up process. We look at the operation phase first, and deal with the fi-up process afterwards. INSERT(R,): We can set size() := 1, and simpl increment the size field for ever ancestor of. DELETE(R,): onsider the node that is actuall removed b the operation (so = or = succ()). We know the size of the subtree rooted at ever node on the path from to the root decreases b 1, so we simpl traverse that path to decrement the size of each node. We ve shown how to modif the INSERT and DELETE operations themselves. If we show how to do rotations and keep the size fields correct, then we ll know how to do the whole fi-up process, since each case just consists of a rotation and/or a recoloring (recoloring does not affect the size field of an node). Rotations: onsider right rotations (left rotations are similar). Rotate right around - size() = size()+size()+size()+2 size() = size()+size()+1 size()=size()+size()+size()+2 size()=size()+size()+1 22

5 The onl size fields that change are those of nodes and, and the change is easil computed from the information available. So each rotation can be performed while maintaining the size information with onl a constant amount of etra work. Update time: We have onl added a constant amount of etra work during the first phase of each operation, and during each rotation, so the total time is still Θ(log n). Now, we have finall achieved what we wanted: each operation (old or new) takes time Θ(log n) in the worst-case. 23