Orthogonal Range Searching I Range Trees Range Searching

Orthogonal Range Searching I Range Trees

Range Searching • S = set of geometric objects • Q = query object • Report/Count objects in S that intersect Q Query Q Report/Count answers

Single-shot Vs Repeatitive • Query may be: • Single-shot (one-time). No need to preprocess • Repeatitive-Mode. Many queries are expected. Preprocess S into a Data Structure so that queries can be answered fast

Efficiency Measures • Repetitive-Mode – Preprocessing Time: P(n) – Space occupied by Data Structure: S(n) – Query Time: Q(n) – Dynamic Case: Update Time U(n) • Single-Shot – Space S(n) and Time T(n)

Orthogonal Range Searching in 1 D • S: Set of points on real line. • Q= Query Interval [a, b] a b Which query points lie inside the interval [a, b]?

Orthogonal Range Searching in 2 D • S = Set of points in the plane • Q = Query Rectangle

Binary search trees A binary search tree (BST) is a binary tree which has the following properties: • Each node has a value. • A total order is defined on these values. • The left subtree of a node contains only values less than the node's value. • The right subtree of a node contains only values greater than or equal to the node's value. The major advantage of binary search trees is that the related sorting algorithms and search algorithms such as in-order traversal can be very efficient.

1 D Range Query Build a balanced search tree where all data points are stored in the leaves. 6 2 4 5 17 7 8 12 15 19 7 query: O(log n+k) space: O(n) 4 12 2 2 5 4 5 8 7 8 15 12 15 19

Querying Strategy • Given interval [a, b], search for a and b • Find where the paths split, look at subtrees inbetween Paths split a b Problem: linking leaves do not extends to higher dimensions. Idea: if parents knew all descendants, wouldn’t need to link leaves.

Efficiency • Preprocessing Time: O(n log n) • Space: O(n) • Query Time: O(log n + k) • k = number of points reported • Output-sensitive query time • Binary search tree can be kept balanced in O(log n) time per update in dynamic case

1 D Range Counting • S = Set of points on real line • Q= Query Interval [a, b] • Count points in [a, b] Solution: At each node, store count of number of points in the subtree rooted at the node. Query: Similar to reporting but add up counts instead of reporting points. • Query Time: O(log n)

2 D Range queries • How do you efficiently find points that are inside of a rectangle? – Orthogonal range query ([x 1, x 2], [y 1, y 2]): find all points (x, y) such that x 1<x<x 2 and y 1<y<y 2 y 1 x 2 x

Range trees – Canonical subset P(v) of a node v in a BST is a set of points (leaves) stored in a subtree rooted at v n Range tree is a multi-level data structure: • The main tree is a BST T on the x -coordinate of points • Any node v of T stores a pointer to a BST Ty(v) (associated structure of v), which stores canonical subset P(v) organized on the y-coordinate • 2 D points are stored in all leaves! BST on y-coords Ty(v) T v P ( v) BST on x-coords P ( v)

Range trees For each internal node v Tx let P(v) be set of points stored in leaves of subtree rooted at v. Set P(v) is stored with v as another balanced binary search tree Ty(v) (descendants by y) on y-coordinate. (have pointer from v to Ty(v)) Tx p 4 Ty(v) p 5 p 1 p 2 p 3 Ty(v) T 4 p 6 v p 7 p 5 P(v) p 1 p 2 p 3 p 4 p 5 p 6 p 7 P(v) 14

Range trees The diagram below shows what is stored at one node. Show what is stored at EVERY node. Note that data is only stored at the leaves. x y p 1 1 2. 5 p 2 2 1 p 3 3 0 p 4 4 4 p 5 4. 5 3 p 6 5. 5 3. 5 p 7 6. 5 2 Tx p 4 Ty(v) p 5 p 1 p 2 p 3 Ty(v) T 4 p 6 v p 7 p 5 P(v) p 1 p 2 p 3 p 4 p 5 p 6 p 7 P(v) 15

Range trees The query time: Querying a 1 D-tree requires O(log n+k) time. How many 1 D trees (associated structures) do we need to query? Query: [x, x’] At most 2 height of T = 2 log n Each 1 D query requires O(log n+k’) time. Query time = O(log 2 n + k) x x’ Answer to query = Union of answers to subqueries: k = ∑k’.

Size of the range tree • Size of the range tree: – At each level of the main tree associated structures store all the data points once (with constant overhead): O(n). – There are O(log n) levels. – Thus, the total size is O(n log n).

Building the range tree • Efficient building of the range tree: – Sort the points on x and on y (two arrays: X, Y). – Take the median v of X and create a root, build its associated structure using Y. – Split X into sorted XL and XR, split Y into sorted YL and YR (s. t. for any pÎXL or pÎYL, p. x < v. x and for any pÎXR or pÎYR, p. x ³ v. x). – Build recursively the left child from XL and YL and the right child from XR and YR. • The running time is O(n log n).

Generalizing to higher dimensions • d-dimensional Range Tree can be build recursively from (d-1) dimensional range trees. • Build a Binary Search Tree on coordinates for dimension d. • Build Secondary Data Structures with (d-1) dimensional Range Trees. • Space O(n logd-1 n). • Query Time O(logd n + k).

Fractional Cascading • Search on a subset can be speeded up by adding pointers 3 10 19 10 23 19 33 38 33 42 42 55 55 68 66 68

Layered Range Trees • Node v and subtrees Left(v) and Right(v). • Secondary Structures T(Left(v)) and T(Right(v)) are built on subsets of points on which secondary structure T(v) is built. • Fractional Cascading can be used to speed up searches. • d-dimensional (d >= 2) Range Tree with fractional cascading: – Space: O(n logd-1 n) – Query Time: O(logd-1 n + k)

Range trees: summary • Range trees – Building (preprocessing time): O(n log n) – Size: O(n log n) – Range queries: O(log 2 n + k) • Running time can be improved to O(log n + k) without sacrificing the preprocessing time or size: – Layered range trees (uses fractional cascading)

Application • Given a set of rectangles, report all pairs of rectangles (R 1, R 2) such that R 1 encloses R 2 d y 2 y 1 c a x 1 x 2 b

Reduction to Range Search • x 1 >= a, x 2 <= b, y 1 >= c, y 2 <= d. • x 1 ε [a, infty], x 2 ε [-infty, b], • y 1 ε [c, infty], y 2 ε [-infty, d]. • This is a 4 D Range Search Problem: – Map each rectangle to 4 D point and create a data structure D. – Map each rectangle to 4 D interval and query D. – O(n log 3 n) space and O(log 4 n + k) query time, but O(log 3 n + k) query time using fractional cascading.

Orthogonal Range Searching II Interval Trees

1 D point enclosure S : set of n intervals on the real line. q : query point. Query: Which intervals contain Q? Build a data structure with the intervals, so that queries can be answered fast.

Subdivide the problem • Consider all 2 n endpoints. • Xmid = Median of the endpoints. • At most half the midpoints are to the left of the median, at most half to the right. • Construct a binary tree based on this idea with Xmid as the “root discriminator”.

Subdivide set of intervals What do we do with the segments that intersect xmid? Imid Ileft xmid Iright

Interval trees Idea: Use an associated data structure! xmid Imid

Interval trees Idea: L xmid Store the segments twice; once for the left endpoints and once for the right endpoints. L Need sorted list of left and right endpoints Sorted list of left endpoints

Recursive subdivision Left and right subtrees are interval trees. The interval tree has O(log n) depth and uses O(n) storage (each interval gets stored exactly at one node).

Querying If q < Xmid – consider left endpoints in Imid – query left subtree recursively Else – consider right endpoints in Imid – query right subtree recursively

Efficiency • Preprocessing Time O(n log n). • Space O(n). • Query Time = O(log n + k) : – we visit at most one node at any depth of the tree. – we report kv intervals at node v. – k = total number of intervals reported, k = ∑kv.

Application S: set of horizontal line segments in the plane. q: vertical line segment. Query: find all horizontal segments intersecting q. q

Solution • Build Interval Tree on Horizontal Segments. • Instead of storing left and right endpoints in an ordered list we need a secondary data structure at each node. Secondary data structure = 2 D range tree

Analysis • Secondary data structure = 2 D range tree: – O(n log n) space. – O(log n + k’) query time. • Overall: – Preprocessing Time: O(n log n). – Space: O(n log n) (we have range trees instead of ordered lists). – At each of the O(log n) nodes v on the search path we spend O(log n + kv) time. – Overall Query Time: O(log 2 n + k). k = total number of intervals reported, k = ∑kv.

Windowing Query S: axes parallel segments. q: query axes parallel rectangle. Query: find all horizontal segments intersecting q.

Solution • Can be solved with range trees and interval trees. • Consider 2 subproblems: – Intervals with some endpoint in query. Range trees: • • O(log n + k’) query time O(n log n) space and preprocessing – Number of endpoints inside query. Interval trees: • • • O(log 2 n + k’’) query time O(n log n) space and preprocessing Overall: – Preprocessing Time: O(n log n). – Query Time O(log 2 n + k). – Space O(n log n).