1 / 37

CS 332: Algorithms

CS 332: Algorithms. Augmenting Data Structures: Interval Trees. Review: Dynamic Order Statistics. We’ve seen algorithms for finding the i th element of an unordered set in O( n ) time OS-Trees : a structure to support finding the i th element of a dynamic set in O(lg n ) time

willard
Télécharger la présentation

CS 332: Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 332: Algorithms Augmenting Data Structures: Interval Trees David Luebke 16/4/2014

  2. Review: Dynamic Order Statistics • We’ve seen algorithms for finding the ith element of an unordered set in O(n) time • OS-Trees: a structure to support finding the ith element of a dynamic set in O(lg n) time • Support standard dynamic set operations (Insert(), Delete(), Min(), Max(), Succ(), Pred()) • Also support these order statistic operations: void OS-Select(root, i); int OS-Rank(x); David Luebke 26/4/2014

  3. M8 C5 P2 Q1 A1 F3 D1 H1 Review: Order Statistic Trees • OS Trees augment red-black trees: • Associate a size field with each node in the tree • x->size records the size of subtree rooted at x, including x itself: David Luebke 36/4/2014

  4. M8 C5 P2 Q1 A1 F3 D1 H1 Review: OS-Select • Example: show OS-Select(root, 5): OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } David Luebke 46/4/2014

  5. M8 C5 P2 Q1 A1 F3 D1 H1 i = 5r = 6 Review: OS-Select • Example: show OS-Select(root, 5): OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } David Luebke 56/4/2014

  6. M8 C5 P2 Q1 A1 F3 D1 H1 i = 5r = 6 Review: OS-Select • Example: show OS-Select(root, 5): OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } i = 5r = 2 David Luebke 66/4/2014

  7. M8 C5 P2 Q1 A1 F3 D1 H1 i = 5r = 6 Review: OS-Select • Example: show OS-Select(root, 5): OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } i = 5r = 2 i = 3r = 2 David Luebke 76/4/2014

  8. M8 C5 P2 Q1 A1 F3 D1 H1 i = 5r = 6 Review: OS-Select • Example: show OS-Select(root, 5): OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } i = 5r = 2 i = 3r = 2 i = 1r = 1 David Luebke 86/4/2014

  9. M8 C5 P2 Q1 A1 F3 D1 H1 i = 5r = 6 Review: OS-Select • Example: show OS-Select(root, 5): Note: use a sentinel NIL element at the leaves with size = 0 to simplify code, avoid testing for NULL OS-Select(x, i) { r = x->left->size + 1; if (i == r) return x; else if (i < r) return OS-Select(x->left, i); else return OS-Select(x->right, i-r); } i = 5r = 2 i = 3r = 2 i = 1r = 1 David Luebke 96/4/2014

  10. M8 C5 P2 Q1 A1 F3 D1 H1 Review: Determining The Rank Of An Element Idea: rank of right child x is onemore than its parent’s rank, plus the size of x’s left subtree OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 106/4/2014

  11. M8 C5 P2 Q1 A1 F3 D1 H1 yr = 1 Review: Determining The Rank Of An Element Example 1: find rank of element with key H OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 116/4/2014

  12. M8 C5 P2 Q1 A1 F3 D1 H1 r = 1 yr = 1+1+1 = 3 Review: Determining The Rank Of An Element Example 1: find rank of element with key H OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 126/4/2014

  13. M8 C5 P2 Q1 A1 F3 D1 H1 r = 1 r = 3 yr = 3+1+1 = 5 Review: Determining The Rank Of An Element Example 1: find rank of element with key H OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 136/4/2014

  14. M8 C5 P2 Q1 A1 F3 D1 H1 r = 1 r = 3 r = 5 yr = 5 Review: Determining The Rank Of An Element Example 1: find rank of element with key H OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 146/4/2014

  15. M8 C5 P2 Q1 A1 F3 D1 H1 yr = 1 Review: Determining The Rank Of An Element Example 2: find rank of element with key P OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 156/4/2014

  16. M8 C5 P2 Q1 A1 F3 D1 H1 r = 1 yr = 1 + 5 + 1 = 7 Review: Determining The Rank Of An Element Example 2: find rank of element with key P OS-Rank(T, x) { r = x->left->size + 1; y = x; while (y != T->root) if (y == y->p->right) r = r + y->p->left->size + 1; y = y->p; return r; } David Luebke 166/4/2014

  17. Review: Maintaining Subtree Sizes • So by keeping subtree sizes, order statistic operations can be done in O(lg n) time • Next: maintain sizes during Insert() and Delete() operations • Insert(): Increment size fields of nodes traversed during search down the tree • Delete(): Decrement sizes along a path from the deleted node to the root • Both: Update sizes correctly during rotations David Luebke 176/4/2014

  18. Reivew: Maintaining Subtree Sizes • Note that rotation invalidates only x and y • Can recalculate their sizes in constant time • Thm 15.1: can compute any property in O(lg n) time that depends only on node, left child, and right child y19 x19 rightRotate(y) x11 y12 7 6 leftRotate(x) 6 4 4 7 David Luebke 186/4/2014

  19. Review: Methodology For Augmenting Data Structures • Choose underlying data structure • Determine additional information to maintain • Verify that information can be maintained for operations that modify the structure • Develop new operations David Luebke 196/4/2014

  20. 7 10 i = [7,10]; i low = 7; ihigh = 10 5 11 17 19 4 8 15 18 21 23 Interval Trees • The problem: maintain a set of intervals • E.g., time intervals for a scheduling program: David Luebke 206/4/2014

  21. 7 10 i = [7,10]; i low = 7; ihigh = 10 5 11 17 19 4 8 15 18 21 23 Interval Trees • The problem: maintain a set of intervals • E.g., time intervals for a scheduling program: • Query: find an interval in the set that overlaps a given query interval • [14,16]  [15,18] • [16,19]  [15,18] or [17,19] • [12,14]  NULL David Luebke 216/4/2014

  22. Interval Trees • Following the methodology: • Pick underlying data structure • Decide what additional information to store • Figure out how to maintain the information • Develop the desired new operations David Luebke 226/4/2014

  23. Interval Trees • Following the methodology: • Pick underlying data structure • Red-black trees will store intervals, keyed on ilow • Decide what additional information to store • Figure out how to maintain the information • Develop the desired new operations David Luebke 236/4/2014

  24. Interval Trees • Following the methodology: • Pick underlying data structure • Red-black trees will store intervals, keyed on ilow • Decide what additional information to store • We will store max, the maximum endpoint in the subtree rooted at i • Figure out how to maintain the information • Develop the desired new operations David Luebke 246/4/2014

  25. Interval Trees intmax [17,19] [5,11] [21,23] [4,8] [15,18] [7,10] What are the max fields? David Luebke 256/4/2014

  26. Interval Trees intmax [17,19]23 [5,11]18 [21,23]23 [4,8]8 [15,18]18 [7,10]10 Note that: David Luebke 266/4/2014

  27. Interval Trees • Following the methodology: • Pick underlying data structure • Red-black trees will store intervals, keyed on ilow • Decide what additional information to store • Store the maximum endpoint in the subtree rooted at i • Figure out how to maintain the information • How would we maintain max field for a BST? • What’s different? • Develop the desired new operations David Luebke 276/4/2014

  28. [11,35]35 [6,20]??? rightRotate(y) [6,20]20 …30 …??? [11,35]??? leftRotate(x) …14 …19 …??? …??? Interval Trees • What are the new max values for the subtrees? David Luebke 286/4/2014

  29. [11,35]35 [6,20]??? rightRotate(y) [6,20]20 …30 … 14 [11,35]??? leftRotate(x) …14 …19 … 19 … 30 Interval Trees • What are the new max values for the subtrees? • A: Unchanged • What are the new max values for x and y? David Luebke 296/4/2014

  30. [11,35]35 [6,20]35 rightRotate(y) [6,20]20 …30 … 14 [11,35]35 leftRotate(x) …14 …19 … 19 … 30 Interval Trees • What are the new max values for the subtrees? • A: Unchanged • What are the new max values for x and y? • A: root value unchanged, recompute other David Luebke 306/4/2014

  31. Interval Trees • Following the methodology: • Pick underlying data structure • Red-black trees will store intervals, keyed on ilow • Decide what additional information to store • Store the maximum endpoint in the subtree rooted at i • Figure out how to maintain the information • Insert: update max on way down, during rotations • Delete: similar • Develop the desired new operations David Luebke 316/4/2014

  32. Searching Interval Trees IntervalSearch(T, i) { x = T->root; while (x != NULL && !overlap(i, x->interval)) if (x->left != NULL && x->left->max  i->low) x = x->left; else x = x->right; return x } • What will be the running time? David Luebke 326/4/2014

  33. [17,19]23 [5,11]18 [21,23]23 [4,8]8 [15,18]18 [7,10]10 IntervalSearch() Example • Example: search for interval overlapping [14,16] IntervalSearch(T, i) { x = T->root; while (x != NULL && !overlap(i, x->interval)) if (x->left != NULL && x->left->max  i->low) x = x->left; else x = x->right; return x } David Luebke 336/4/2014

  34. [17,19]23 [5,11]18 [21,23]23 [4,8]8 [15,18]18 [7,10]10 IntervalSearch() Example • Example: search for interval overlapping [12,14] IntervalSearch(T, i) { x = T->root; while (x != NULL && !overlap(i, x->interval)) if (x->left != NULL && x->left->max  i->low) x = x->left; else x = x->right; return x } David Luebke 346/4/2014

  35. Correctness of IntervalSearch() • Key idea: need to check only 1 of node’s 2 children • Case 1: search goes right • Show that  overlap in right subtree, or no overlap at all • Case 2: search goes left • Show that  overlap in left subtree, or no overlap at all David Luebke 356/4/2014

  36. Correctness of IntervalSearch() • Case 1: if search goes right,  overlap in the right subtree or no overlap in either subtree • If  overlap in right subtree, we’re done • Otherwise: • xleft = NULL, or x  left  max < x  low (Why?) • Thus, no overlap in left subtree! while (x != NULL && !overlap(i, x->interval)) if (x->left != NULL && x->left->max  i->low) x = x->left; else x = x->right; return x; David Luebke 366/4/2014

  37. Correctness of IntervalSearch() • Case 2: if search goes left,  overlap in the left subtree or no overlap in either subtree • If  overlap in left subtree, we’re done • Otherwise: • i low  x left max, by branch condition • x left max = y high for some y in left subtree • Since i and y don’t overlap and i low  y high,i high < y low • Since tree is sorted by low’s, i high < any low in right subtree • Thus, no overlap in right subtree while (x != NULL && !overlap(i, x->interval)) if (x->left != NULL && x->left->max  i->low) x = x->left; else x = x->right; return x; David Luebke 376/4/2014

More Related