Augmenting Data Structures

Transcription

1 Augmenting Data Structures

2 Augmenting Data Structures Let s look at two new problems: Dynamic order statistic Interval search It is unusual to have to design all-new data structures from scratch Typically: store additional information in an already known data structure The augmented data structure can support new operations We need to correctly maintain the new information without loss of efficiency 2/3/08 2

3 Dynamic Order Statistics Def.: the i-th order statistic of a set of n elements, where i {, 2,, n} is the element with the i-th smallest key. We can retrieve an order statistic from an unordered set: Using: RANDOMIZED-SELECT In: O(n) time With red-black trees we can achieve this in O(lgn) Finding the rank of an element takes also O(lgn) 2/3/08 3

4 Order-Statistic-Tree Def.: Order-statistic tree: a red-black tree with additional information stored in each node Node representation: Usual fields: x.key, x.color, x.p, x.left, x.right Additional field: x.size that contains the number of (internal) nodes in the subtree rooted at x (including x itself) For any internal node of the tree: x.size = x.left.size + x.right.size + 2/3/08 4

5 Example: Order Statistic Tree 0 7 key size /3/08 5

6 OS-SELECT Goal: Given an order-statistic-tree, return a pointer to the node containing the i-th smallest key in the subtree rooted at x Idea: x.left.size = the number of nodes that are smaller than x x.rank = x.left.size + in the subtree rooted at x If i = x.rank Done! If i < x.rank: look left If i > x.rank: look right /3/08 6

7 OS-SELECT(x, i). r x.left.size + 2. if i = r 3. then return x 4. elseif i < r compute the rank of x within the subtree rooted at x 5. then return OS-SELECT(x.left, i) 6. else return OS-SELECT(x.right, i - r) Initial call: OS-SELECT(T.root, i) Running time: O(lgn) 2/3/08 7

8 Example: OS-SELECT OS-SELECT(root, 3) 0 7 r = 3 + = 4 OS-SELECT(root, 3) r = + = 2 OS-SELECT( 8, 3) /3/08 8 r = OS-SELECT( 8, ) 9

9 OS-RANK Goal: Given a pointer to a node x in an order-statistic tree, return the rank of x in the linear order determined by an inorder walk of T Its parent plus the left subtree if x is a right child 0 7 x Idea: Add elements in the left subtree Go up the tree and if a right child: add the elements in the left subtree of the parent The elements in the left subtree 9

10 OS-RANK(T, x). r x.left.size + 2. y x 3. while y T.root Add to the rank the elements in its left subtree + for itself Set y as a pointer that will traverse the tree 4. do if y = y.p.right 5. then r r + y.p.left.size + 6. y y.p 7. return r Running time: O(lgn) If a right child add the size of the parent s left subtree + for the parent 0

11 Example: OS-RANK y = T.root r = r = r = r + + = 4 y y r = r = x y = x r = + =

12 Maintaining Subtree Sizes We need to maintain the size field during INSERT and DELETE operations Need to maintain them efficiently Otherwise, might have to recompute all size fields, at a cost of Ω(n) 2/3/08 2

13 Maintaining Size for OS-INSERT Insert in a red-black-tree has two stages. Perform a binary-search tree insert 2. Change node colors to restore red-black-trees properties 3

14 OS-INSERT Idea for maintaining the size field during insert Phase (going down): Increment x.size for each node x on the traversed path from the root to the leaves 0 7 The new node gets a size of Additional cost: O(lgn)

15 OS-INSERT Idea for maintaining the size field during insert Phase 2 (going up): 6 During RB-INSERT-FIXUP there are: O(lgn) changes in node colors At most two rotations Rotations affect the subtree sizes!! 42 9 x 93 2 y LEFT-ROTATE(T, x) y.size = x.size x.size = x.left.size + x.right.size + 42 x 93 9 y Maintain size in: O(lgn) 6 4 5

16 Augmenting a Data Structure. Choose an underlying data structure Red-black trees 2. Determine additional information to maintain x.size 3. Verify that we can maintain additional information for existing data structure operations 4. Develop new operations Shown how to maintain size during modifying operations Developed OS-RANK and OS-SELECT 2/3/08 6

17 Augmenting Red-Black-Trees Theorem: Let f be a field that augments a red-black tree. If the contents of f for a node can be computed using only the information in x, x.left, x.right, x.left.f and x.right.f, we can maintain the values of f in all nodes during insertion and deletion, without affecting their O(lgn) running time. 2/3/08 7

18 Examples. Can we augment a RBT with x.size? Yes: x.size = x.left.size + x.right.size + 2. Can we augment a RBT with x.height? Yes: x.height = + max(x.left.height, x.right.height) 3. Can we augment a RBT with x.rank? No, inserting a new minimum will cause all n rank values to change 2/3/08 8

19 Problem Given an element x in an n-node order statistic tree and a natural number i, how can the i-th successor of x in the linear order of the tree be determined in O(logn) time? Def: successor (x ) = y, such that y.key is the smallest key > x.key Operations on order-statistic trees: OS-RANK(x) OS-SELECT(T, i) Alg.: OS-SUCCESSOR(T, x, i ) r OS-RANK(T, x) s r + i return OS-SELECT(T.root, s) rank(3) = 7 2/3/08 9

20 Interval Trees Useful for representing a set of intervals E.g.: time intervals of various events Each interval i has a i.low and a i.high 20

21 Interval Properties Intervals i and j overlap iff: i.low j.high and j.low i.high i i i i j j j j Intervals i and j do not overlap iff: i.high < j.low or j.high < i.low i j j i 2

22 Interval Trichotomy Any two intervals i and j satisfy the interval trichotomy: exactly one of the following three properties holds: a) i and j overlap, b) i is to the left of j (i.high < j.low) c) i is to the right of j (j.high < i.low) 22

23 Interval Trees Def.: Interval tree = a red-black tree that maintains a dynamic set of elements, each having associated an interval x.int. Operations on interval trees: INTERVAL-INSERT(T, x) INTERVAL-DELETE(T, x) INTERVAL-SEARCH(T, i) 23

24 Designing Interval Trees. Underlying data structure Red-black trees Each node x contains: an interval x.int, and the key: x.int.low An inorder tree walk will list intervals sorted by their low endpoint 2. Additional information x.max = maximum endpoint value in subtree rooted at x 3. Maintaining the information x.max = max Takes O() time x.int.high x.left.max x.right.max 24

25 Designing Interval Trees 4. Develop new operations INTERVAL-SEARCH(T, i): Returns a pointer to an element x in the interval tree T, such that x.int overlaps with i, or NIL otherwise Idea: Check if x.int overlaps with i x.left.max i.low Go left Otherwise, go right [5, 8] 0 [8, 9] 23 [5, 23] 23 [6, 2] 30 [7, 9] 20 low [25, 30] 30 [22, 25] [26, 26] 26 high [0, 3] 3 [6, 0] 0 [9, 20] 20 25

26 Example i = [, 4] [6, 2] 30 x i = [22, 25] x [8, 9] 23 x [25, 30] 30 [5, 8] 0 [5, 23] 23 [7, 9] 20 [26, 26] 26 [0, 3] 3 [6, 0] 0 x = NIL [9, 20] 20 26

27 INTERVAL-SEARCH(T, i). x T.root 2. while x T.nil and i does not overlap x.int 3. do if x.left T.nil and x.left.max i.low 4. then x x.left 5. else x x.right 6. return x 2/3/08 27

28 Theorem At the execution of interval search: if the search goes right, then either: There is an overlap in right subtree, or There is no overlap in either subtree Similar when the search goes left It is safe to always proceed in only one direction 2/3/08 28

29 Theorem Proof: If search goes right: If there is an overlap in right subtree, done If there is no overlap in right show there is no overlap in left Went right because: x.left = T.nil no overlap in left, or x.left.max < i.low no overlap in left i x.left.max i.low 2/3/08 29

30 Theorem - Proof If search goes left: If there is an overlap in left subtree, done If there is no overlap in left, show there is no overlap in right Went left because: i.low x.left.max = j.high for some j in left subtree x.left.max [x.low,x.high] [j.low, j.high] j.high [k.low, k.high] i j i k i.high < j.low j.high < i.low j.low < k.low No overlap! i.high < k.low 30