Augmenting Data Structures

Transcription

1 Augmenting Data Structures [Not in G &T Text. In CLRS chapter 14.] An AVL tree by itself is not very useful. To support more useful queries we need more structure. General Definition: An augmented data structure is simply an existing data structure modified to store additional information and/or perform additional operations. Example: We want a data structure that will allow us to answer two types of rank queries on sets of values, in addition to the standard operations for maintaining the set (INSERT, DELETE, SEARCH): RANK(k): Given a key k, what is its rank, i.e., its position among the SELECT(r): Given a rank r, which key has this rank? For example, if our set of values is 3,15,27,30,56, then RANK(15) = 2 and SELECT(4) =

2 Let s look at 3 different ways we could do this. 1. Use AVL trees without modification. Queries: Simply do an inorder traversal of the tree, keeping track of t Q: What will be the time for a query? at worst O(n) because we have may have to visit every node if our r Q: Will the other operations (SEARCH/INSERT/DELETE) take any longer? no. Q: What is the problem? Could we do better? very inefficient. 2. Augment AVL trees so that each node has an additional field rank[x] that stores its rank in the tree. Q: What will be the time for a query? For RANK(k), the same as SEARCH, or O(log n). For SELECT(r), we can search just like for RANK, so O(log n). 36

3 Q: Will the other operations (SEARCH/INSERT/DELETE) take any longer? Q: What is the problem? Could we do better? 3. Augment the tree in a more sophisticated way. Q: How can we augment the nodes of AVL trees so that we can perform our queries faster? Q: What would help us with questions about rank? augment each node x such that it has an additional field size[x] t Q: How is this related to rank? Suppose we have a node with key x. What is rank(x) in terms of the keys that come before x in the tree? RANK(x) = 1 + # keys that come before x in the tree. Q: Now with respect to the left subtree rooted at x, what is the relative RANK(x)? RANK(x) = SIZE(T L ) + 1 where T L is the left child. So the rank of a node is related to the size of the subtrees rooted at neighbouring nodes. 37

4 Let s look at rank queries more closely: Computing RANK(k): Given key k, do a SEARCH(k) keeping track of the rank of the current node. Each time you go down a level you must add the size of the subtrees Think of this as the relative rank of the key to the left of the subtree Let the current node be v with key k. We can denote the left child as v l and the right child as v r. Consider the SEARCH algorithm for AVL trees: SEARCH(v, key): 1 if v is a leaf, return NIL. \\(k is not the in the tree.) 2 if k = key 3 return v 4 if key < k 5 return SEARCH(v_l, key) 6 else 7 return SEARCH(v_r, key) Q: When we recursively call SEARCH(v r,k) what do we add to our current rank total r? size of subtree rooted at v l +1 38

5 Q: When we find x how do we determine its true rank? take the current rank so far, r, and add the size of the x 0 s left child. Note that we did not deal with degenerate cases (such as when k does no Finding the key with rank r. SELECT(r): Given rank r, Start at x = root[t] and work down. Let S be the left child. Compare r to size[s] + 1. If they are equal return x. If (r < size[s] +1), we know that the element we are looking for is in S, so call the routine recursively on S. If (r > size[s] + 1), then we know the node we are looking for is in the right subtree, so the relative rank in the remaining elements (ignoring S) is equal to r - (size[s] + 1) so we change r accordingly and go down the right subtree of S. 39

6 Once again, we did not deal with degenerate cases (such as when r is a r Q: What will be the complexity for a rank query? same as SEARCH, ie. O(log n). Q: What about the updates: INSERT and DELETE? These operations consist of two phases for AVL trees: the operation itself, followed by the rebalance process. We ll look at the operation phase first, and check the rebalance process only once afterwards. Operations: INSERT(x): Simply increment the size of the subtree rooted at ever DELETE(x): Consider the element y that is actually removed by the operation (so y = x or y = successor(x)). What do we know about the sizes of the subtree rooted at every node on the path from the root down to y? It decreases by 1, so we simply traverse that path to decrement the Rebalance Process: Rotation: Consider rotation about a node. We may need to move subtrees and update size properties accordingly. For each rotation we only need to consider a constant number of nodes, so each rotation takes (1) time. We have finally achieved what we wanted: each operation (old or new) takes time (log n) in the worst-case. 40

7 Other Balanced Search Trees Trees A tree (also called a (2,4) tree) is similar to the BST in that it stores key:value pairs in the internal nodes and has a similar property relating the keys stored in a subtree to the keys in the parent node. but different from a BST because Each internal node has a size property. node can have 2, 3 or 4 children. I.e., an internal The tree has a depth property I.e., all external nodes must be at the same depth. Here is an example of a tree Consider the node (4,9): it contains two keys and has three children (the nodes (1,2,3), (7,8), and (12)). 41

8 Notice the property relating the values in a subtree to the values in the parent node of it s root. For example, Consider the subtree rooted at node (20,30,41). All keys in this subtree must be greater than 17. Now consider the subtree rooted at node (7,8). All values in this subtree must be greater than 4 and less than Q. What happens if we insert 6 into the tree? Q. What happens if we insert 5 into the tree after inserting 6? 42

9 2-3-4 Trees Deletion Consider the following tree: Q: How would the tree change if we deleted the element with key 2? simply replace the 4-node (1,2,3) by the 3-node (1,3). Q: What would be the problem if we deleted the element 4 in the same way? too many children for the number of keys Using the same approach as for BST s we find the predecessor for 4 and swap the elements. So, in this case: We take 4 s predecessor, 3, and delete it, replacing 4 with

10 B-trees B-trees are a generalization of trees. B-trees are multiway trees with all leaves at the same level and a varying number of children per node. A B-tree node can hold at most m keys and pointers to m+ 1 children. More formally, the following properties must hold in a B-tree of order m. 1. The root must hold at least 1 key and at most m keys. 2. Each node must hold between b m c keys and m keys All leaves must be at the same level. Q: How does a tree relate to a B-tree? A: A tree is a B-tree of order 3 Q: Consider keeping a search tree on disk. How many disk accesses would it take to search a tree of height h? A: O(h) Q: Why is this so important? This is important because each disk access is very very slow relative to a 44

11 When the OS reads from disk, it reads a minimum of 1 block of data from the disk. Why might this be inefficient for a tree? If all you want is one 2-node from a tree (possibly 12 bytes) the It also has to spin the disk to the correct sector, move the head to the correct track etc. Q: How might one design the tree better to take advantage of the fact that disk access is expensive but once we do the access we read at least one full block of data? A: Make the nodes of the B-tree as large as we can without exceeding 1 Remember that a node with n keys contains n +1children v i : v 1,k 1,v 2,k 2,...,v n,k n,v n+1 Therefore, set n so that the total number of bytes is as close to a block size Similar to trees, B-trees have insertion and deletion algorithms that SPLIT and MERGE as necessary to maintain the properties. 45