Download presentation

Presentation is loading. Please wait.

Published byKaia Homer Modified over 2 years ago

1
**Interval Trees Store intervals of the form [li,ri], li <= ri.**

An interval is stored in exactly 1 node. So, O(n) nodes. 3 versions. Differing capability. Note, when l = r, interval intersection becomes point enclosure.

2
**Version 1 Store intervals of the form [li,ri], li <= ri.**

At least 1 interval per node. Static interval set. Report all intervals that intersect/overlap a given interval [l,r]. Note, when l = r, interval intersection becomes point enclosure.

3
**Definition—Version 1 A binary tree.**

Each node v has a point v.pt and two lists v.left and v.right. u.pt < v.pt for nodes u in left subtree of v. u.pt > v.pt for nodes u in right subtree of v. So, it is a binary search tree on pt.

4
Definition—Version 1 Intervals with ri < v.pt are stored in the left subtree of v. Intervals with li > v.pt are stored in the right subtree of v. Intervals with li <= v.pt <= ri are stored in v. v.left has these intervals sorted by li. v.right has these intervals sorted by ri. Note sorted doesn’t imply an array organization necessarily. Could be a red-black tree, implicitly sorted.

5
**Example e a c b f d v.pt = 4 L = {a, e} R = {d} v.left = {c, f, b}**

1 e 3 a 2 4 c 6 b f 5 7 d 4 L R v v.pt = 4 L = {a, e} R = {d} v.left = {c, f, b} v.right = {c,b,f}

6
**Properties Each interval is stored in exactly one node.**

Each node stores between 1 and n intervals. Number of nodes is O(n). Sum of sizes of left and right lists is O(n). Tree height depends on how you choose the points v.pt.

7
Selection of v.pt v is the median of the end points of the intervals stored in the subtree rooted at v. 1 e 3 a 2 4 c 6 b f 5 7 d End points = {1, 2, 3, 4, 5, 6, 7} Use 4 as v.pt.

8
**Selection of v.pt With median selection, tree height is O(log n).**

Median selection is possible only for static interval set. So, no inserts/deletes. Could relax to support insert/delete.

9
**Find All Overlapping Intervals**

Query interval is [l,r]. v.pt e [l,r] All intervals in v overlap. Search L and R for additional overlapping intervals. 4 L R v l r

10
**Find All Overlapping Intervals**

v.pt < l Intervals in v with ri >= l overlap. No interval in L overlaps. Search R for additional overlapping intervals. 4 L R v l r Search v.right for overlapping intervals. If v.right is a sorted array, start at right end of array and pick off the overlapping intervals. Time is 1 + number of overlapping intervals in v.right.

11
**Find All Overlapping Intervals**

v.pt > r Intervals in v with li <= r overlap. No interval in R overlaps. Search L for additional overlapping intervals. 4 L R v l r Search v.left for overlapping intervals. If v.left is a sorted array, start at left end of array and pick off the overlapping intervals. Time is 1 + number of overlapping intervals in v.left.

12
**Find All Overlapping Intervals**

Complexity O(log n) nodes encountered. All intervals in v overlap. Intervals in v with ri >= l overlap. Intervals in v with li <= r overlap. O(log n + |output|) when v.left and v.right are sorted arrays. 4 L R v l r Look at subtree of visited nodes. If there is no degree 2 node, total number of nodes in subtree is O(log n). Otherwise, mark nodes on leftmost and rightmost paths from root as boundary nodes. Number of boundary nodes is O(log n). Other nodes are interior nodes. Let P be degree 2 node closest to root. All interior nodes are descendents of P. The interval stored in an interior node overlaps the query interval as the query interval includes P.pt and every interior node is also the descendent of another degree 2 node in the visited subtree.

13
**Version 2 Store intervals of the form [li,ri], li <= ri.**

Empty nodes permitted. Inserts and deletes. Answer queries of the form: which intervals include the point d. Note, when l = r, interval intersection becomes point enclosure.

14
**Inserts & Deletes Difficult in version 1 because v.pt is median.**

Select v.pt (almost) arbitrarily and use a red-black tree. Each node stores between 0 and n intervals. At most 2n nodes permissible. Tree height is O(log n). Not completely arbitrary as the intervals stored in the node must contain the point.

15
**Need For Empty Nodes Deletion from a degree 2 node. 20 10 6 2 8 15 40**

30 25 35 7 18 Suppose that deletion of an interval from root causes it to become empty. Delete 20 replace with 18 intervals stored in 10 and 15 (I.e., in all nodes on path from degree 2 node that has become empty to replacement node) may need to be moved to new location (root) of 18. This relocation may cause 10 and 15 to become empty, so we repeat the process! Hence, update is expensive. Note that deletion from a degree 0 or 1 node doesn’t suffer from this problem.

16
**Why Upto 2n Nodes Permissible**

When number of nodes > 2n, at least 1 degree 0 or degree 1 node must be empty. Empty degree 0 and 1 nodes are easily removed. So, no need to keep them around. 2n suffices to avoid having to handle empty degree 2 nodes. Proof, by contradiction. |tree| > 2n >= n+1 empty nodes (ne). Assume all are degree 2 nodes. nn = nonempty nodes, n2 = degree 2 nodes So, n2 >= ne and n >= nn (each nn node has at least 1 interval). So, n2 + n >= ne + nn = |tree|. So, n2 >= |tree| - n. But, n0 = n2 + 1 So, |tree| = n0+n1+n2 = n n1 + n2 > 2n2 >= 2|tree| - 2n > |tree|. When a delete is done and a node becomes empty, it may be necessary to remove up to 2 degree 0/1 nodes to ensure #nodes <= 2*#intervals.

17
**LL Rotation Intervals change only for A and B.**

B’L BR AR After insertion. B A After rotation. BR AR B’L Intervals change only for A and B. Those intervals of A that include B.pt need to be moved into B.

18
Remaining Rotations All insert/delete rotations require relocating intervals from O(1) nodes. O(1) rotations per insert/delete. Complexity of insert/delete is O(f(n) + log n), where f(n) is time needed to relocate O(n) intervals from one node to another. F(n) = log n when the lists are themselves stored as red-black trees and the intervals are either disjoint or nest; n when arrays are used

19
**All intervals that contain d**

d = v.pt All intervals in v. Done! 4 L R v

20
**All intervals that contain d**

d < v.pt Intervals in v with large enough left end point. No interval in R overlaps. Search L for additional overlapping intervals. d > v.pt Similar O(log n + |output|) 4 L R v

21
**Version 3 Store intervals of the form [li,ri], li <= ri.**

Exactly 1 interval per node. Inserts and deletes. Report just 1 overlapping interval. Note, when l = r, interval intersection becomes point enclosure.

22
**Version 3—Structure Red-black tree.**

Each node has exactly one interval v.int and one point v.max. v.max = max (right) end point of intervals in subtree rooted at v. Binary search tree on intervals. So, need an ordering relation for intervals. Subtree rooted at v includes node v.

23
Interval Ordering Ordered by left end points. Tie breaker for equal left end points. i and j are two intervals. i < j iff li < lj or (li = lj and ri > rj) i j i j i j Each node has an interval and a max right end-point. Binary search tree on left end points of intervals. Insert, delete, search (for an overlapping interval) O(log n) time.

24
Example 1 e 3 a 2 4 c 6 b f 5 7 d f,7 e,4 a,3 c,4 d,7 b,6

25
Version 3—Search Search for an interval that has an overlap with Q = [l,r] If v.interval and Q overlap, done. Otherwise, if v.leftChild.max >= l search v.leftChild. Otherwise search v.rightChild. f,7 e,4 a,3 c,4 d,7 b,6 Prove correct by showing (a) if you go into left subtree, then either there is an overlapping interval in left or right has no overlapping interval and (b) if you go into the right subtree then there is no overlapping interval in the left subtree. (b) is easy as leftChild.max < l no overlap in left subtree. For (a), suppose there is no overlapping interval in the left subtree. So, the interval L in the left sub tree that ends at leftChild.max begins after r. All intervals in the right subtree begin at or after the left end point of L and so do not overlap Q. Search time is O(log n).

26
**Version 3—Search v.leftChild.max >= l l r max**

Suppose no interval in left subtree overlaps [l,r]. All intervals in right subtree begin at or after left end point of blue interval, which is an interval in the left subtree that ends at max. max

27
**Version 3—LL Rotation Max values changes only for A and B. A B B’L BR**

AR After insertion. B A After rotation. BR AR B’L Note new max for B may not equal old max for A as an interval has been inserted/deleted. Max values changes only for A and B. A.max = max{A.interval.right, BR.max, AR.max}. B.max = max{B.interval.right, B’L.max, A.max}.

28
Remaining Rotations All insert/delete rotations require computing max for O(1) nodes. O(1) rotations per insert/delete. Complexity of insert/delete is O(log n).

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google