Mehdi Mohammadi March 2015 1 Western Michigan University Department of Computer Science CS 6310 -...
-
Upload
catherine-marshall -
Category
Documents
-
view
214 -
download
0
Transcript of Mehdi Mohammadi March 2015 1 Western Michigan University Department of Computer Science CS 6310 -...
1
Tree Structures for Set of Intervals (4.6-4.10)
Mehdi MohammadiMarch 2015
Western Michigan University
Department of Computer Science
CS 6310 - Advanced Data Structure
2
Orthogonal Range Trees Higher-Dimensional Segment Trees Other Systems of Building Blocks Range-Counting and the Semigroup Model KD-Trees and Related Structures
Content
3
Orthogonal Range-Searching problem◦ Input: a (d-dimensional) box, a set of points◦ Output: all the points in the set that lies in that
box Applications
◦ Geometric applications◦ Database Queries
Select Emp from T where 50K<Salary<75K AND age > 50 AND salesAmount > 500K AND 2011<salesYear<2015 A 5-d orthogonal range query
◦ Preprocessing for queries
Orthogonal Range Trees
4
General situation◦ Set of data points p1, …, pn
Pi = (pi1, …, pid)
◦ d-dimensional query interval [a1,b1[ ×…×[ad,bd[
◦ Return all points pi contained in that interval: a1≤pi1<b1, …, ad ≤ pid<bd
O(fd(n) + k)
Structure◦ Build a balanced search tree for the first coordinates of data
points Each node has its Associated Interval: points whose first
coordinate falls into that interval Build recursively a range search tree for the remaining d-1
coordinates on each node
Orthogonal Range Trees
5
Query: ◦ find O(log n) nodes correspond to [a1,b1[◦ In each of those nodes perform d-1 dimensional
range search for [a2,b2[ × … × [ad, bd[
Orthogonal Range Trees
6
Example 2-d◦ (0,1), (1,5), (2,8), (3,3), (5,0), (6,4), (7,6), (8,7),
(9,9)
Orthogonal Range Trees
1-d range tree
5
1 8
5 8 {(2,8)}{(1,5)}
{(1,5), (2,8)}{(0,1)}
{(0,1), (1,5), (2,8)}
7
Theorem: Orthogonal search trees are static structure supporting d-dimensional range queries in a set of d-dimensional points◦ Query time
Output sensitive time O((log n)d + k) if output consists of k points
◦ Building tree time O(n(log n)d )
◦ Space requirement O(n(log n)d-1)
Orthogonal Range Trees
8
Fractional Cascading◦ When we make a sequence of searches in different
but related sets, we can use the information of search in previous set into the next set.
Algorithm◦ For each node, sort the Associated Intervals by
second coordinate◦ Link each point on this list to
The same point on the left or right lower neighbor The point with the next smaller second coordinate if the
point is missing on that side Or the first point on the list if there is no point with smaller
coordinate
Orthogonal Range Trees
10
Fractional Cascading Search◦ We have a search tree for the first coordinate
We have to select the corresponding nodes to the canonical interval decomposition of the first interval query
◦ Attached to each node is a structure for the search in the second coordinate These structure are linked together for fractional
cascading◦ So that we need to search only in the set
associated with the first node Then reuse that information in all later searches
Orthogonal Range Trees
11
Theorem: Orthogonal range trees with fractional cascading are a static data structure that support d-dimensional orthogonal range queries in a set of d-dimensional point (d>1);◦ Query time
O((log n)d-1 + k) if output consists of k points◦ Building tree time
O(n(log n)d-1 )◦ Space requirement
O(n(log n)d-1)
Orthogonal Range Trees
12
The inverse problem of orthogonal range searching problem
Input: ◦ A set of n ranges (d-dimensional intervals)◦ A query point
Output:◦ All ranges that contain that point
Solvable by generalization over segment tree◦ It is defined recursively
Higher-Dimensional Segment Trees
13
Main structure:◦ A balanced search tree whose keys are the first
coordinates of d-dimensional intervals◦ Each node of that tree contains a d-1 dimensional
segment tree.◦ In this d-1 dimensional segment tree associated
with node p, all intervals are stored for which p is part of the canonical interval decomposition of the first dimension.
Higher-Dimensional Segment Trees
14
Query ◦ Follow the search path of the first coordinate of the
query point◦ In each node perform a (d-1) dimensional query with
the remaining coordinates associated with the node. Theorem: d-dimensional segment tree is a static
data structure that lists all d-dimensional intervals containing a given query key,◦ Build time: O(n(log n)d )◦ Space need: O(n(log n)d )◦ Query time: O((log n)d + k) if there are k such intervals
Higher-Dimensional Segment Trees
15
Improvement: S-tree using fractional cascading Algorithm
◦ Input: rectangles [ai,bi[ × [ci,di[ for i = 1,…, n
1. create balanced search tree T1 for {a1,b1,a2,b2,…,an,bn}
2. attach an empty secondary balanced tree to each node of the first tree
3. for i=1 to n◦ 3.1 start from T1 root, put it on a stack.◦ 3.2 Repeat As long as stack is not empty
Take the current node v from the stack Insert {ci, di} as keys into the tree T2(v)
Higher-Dimensional Segment Trees
16
If intervalOf(v) is not in [ai,bi[ , check v’s left and right subtrees. If their intervals have some intersection with [ai,bi[ , then
put them on the stack.
4. for each i=1,…n◦ 4.1. for all nodes v that belong to the canonical
interval decomposition of [ai,bi[ in T1 Insert rectangle [ai,bi[ × [ci,di[ into the segment tree
T2(v)
Higher-Dimensional Segment Trees
17
5. for each node v of T1◦ Create pointers from each leaf of T2(v) to the
corresponding leaves of T2(v->left) and T2(v->right) 6. for each node v of T1
◦ For each node w of T2(v) create a pointer to the next node above w in T2(v) that has some rectangle associated with it.
Theorem: S-tree is a static data structure that keeps track of a set of n rectangles, and for a given point list all rectangles containing that point◦ Space: O(n(log n)2 )◦ Query time: O(log n + k); if there are k output intervals
Higher-Dimensional Segment Trees
18
Canonical interval decomposition◦ Decompose an interval in a union of a small
number of building blocks To answer a query interval
◦ Decompose the query interval into a union of building blocks
◦ Execute the query on those building blocks.
Other Systems of Building Blocks
19
Building block query requires◦ Decompose the queries◦ Reconstruct the answer from the answer of building
blocks◦ Also, some structure that answers the query for a
fixed block◦ Represent each interval as a union of a small number
of blocks Choice of building blocks tradeoff
◦ Reduce interval query to a small number of blocks needs many building blocks For each block we have to build a structure to answer
queries
Other Systems of Building Blocks
20
Bentley and Maurer (1980) proposal◦ Use an r-level structure for system of blocks
Interpreted as writing numbers to the base n(1/r).
Other Systems of Building Blocks
Intervals of blocks for top level[an(1-1/r), bn(1-1/r)]0≤a<b≤n1/r
O(n2/r) blocks
O(n(j+1)/r) blocks
21
Using r-level blocking we obtain a structure to perform d-dimensional orthogonal range searching◦ Query time: O(rd log n + k) ◦ Preprocessing time: O(rd n1+(2d-2)/r log n)◦ Query time is output sensitive for large r and n.
Other Systems of Building Blocks
Range counting problem ask just for the number of points in a range◦ We do not need output sensitive time complexity
Use orthogonal range tree◦ Instead of concatenating lists, just add up numbers◦ Generalization by giving weight to points
In 1-dimensional version, just ask for the number of keys in an interval
22
Range-Counting and the Semigroup Model
2
3
5
2 2 2
4
9
23
All operations in O(n(log n)d) for a set of n points Difference with range searching
◦ Allow to make dynamic structure Insertion, deletion and rebalance Range searching has large associated trees for nodes
◦ lower bounds for operations are possible: O((log n)d) In the semigroup version
◦ a commutative semigroup (S,+) is specified,◦ each point is assigned a weight from S,◦ Return semigroup sum of the weights of the keys in
an interval Directly from canonical interval decomposition
Range-Counting and the Semigroup Model
24
Another structure to support orthogonal range searching◦ Easy to understand and implement◦ Unsatisfactory performance
2-dimensional KD-Tree:O(n1/2 + k) Orthogonal range tree: O((log n)2 + k)
d-dimensional KD-Tree: O(n1-1/d + k) Orthogonal range tree: O((log n)d + k)
KD-Trees and Related Structures
25
In each node make a comparison to enter the left or right sub-trees◦ In different levels compare against different
coordinates In the root compare against x In the second level compare against y, and so on.
KD-Trees and Related Structures
28
KD-Tree range query◦ Starting in the root, descend into each node
whose node interval has an intersection with the query region
◦ Stop branches when an intersection is empty Time complexity is as large as Ω(√n)
◦ Even in completely balanced tree with distinct keys
◦ This bound cannot be improved
KD-Trees and Related Structures
29
Theorem: KD-Trees are a static data structure that supports d-dimensional or orthogonal range queries in a set of d-dimensional points◦ output sensitive time O(n1-1/d + k) if output consist
of k points◦ Can be built in O(n (log n))◦ Need space O(n)
KD-Trees and Related Structures