Results 1  10
of
29
Cacheoblivious Btrees
, 2000
"... Abstract. This paper presents two dynamic search trees attaining nearoptimal performance on any hierarchical memory. The data structures are independent of the parameters of the memory hierarchy, e.g., the number of memory levels, the blocktransfer size at each level, and the relative speeds of me ..."
Abstract

Cited by 135 (22 self)
 Add to MetaCart
Abstract. This paper presents two dynamic search trees attaining nearoptimal performance on any hierarchical memory. The data structures are independent of the parameters of the memory hierarchy, e.g., the number of memory levels, the blocktransfer size at each level, and the relative speeds of memory levels. The performance is analyzed in terms of the number of memory transfers between two memory levels with an arbitrary blocktransfer size of B; this analysis can then be applied to every adjacent pair of levels in a multilevel memory hierarchy. Both search trees match the optimal search bound of Θ(1+logB+1 N) memory transfers. This bound is also achieved by the classic Btree data structure on a twolevel memory hierarchy with a known blocktransfer size B. The first search tree supports insertions and deletions in Θ(1 + logB+1 N) amortized memory transfers, which matches the Btree’s worstcase bounds. The second search tree supports scanning S consecutive elements optimally in Θ(1 + S/B) memory transfers and supports insertions and deletions in Θ(1 + logB+1 N + log2 N) amortized memory transfers, matching the performance of the Btree for B = B Ω(log N log log N).
CacheOblivious Streaming Btrees
, 2007
"... A streaming Btree is a dictionary that efficiently implements insertions and range queries. We present two cacheoblivious streaming Btrees, the shuttle tree, and the cacheoblivious lookahead array (COLA). For blocktransfer size B and on N elements, the shuttle tree implements searches in optima ..."
Abstract

Cited by 17 (5 self)
 Add to MetaCart
A streaming Btree is a dictionary that efficiently implements insertions and range queries. We present two cacheoblivious streaming Btrees, the shuttle tree, and the cacheoblivious lookahead array (COLA). For blocktransfer size B and on N elements, the shuttle tree implements searches in optimal O ` logB+1 N ´ transfers, range queries of L successive elements in optimal O ` logB+1 N + L/B ´ transfers, and insertions in O “ (logB+1 N)/BΘ(1/(loglogB)2 ”) +(log2 N)/B transfers, which is an asymptotic speedup over traditional Btrees if B ≥ (logN) 1+c/logloglog2 N for any constant c> 1. A COLA implements searches in O(logN) transfers, range queries in O(logN + L/B) transfers, and insertions in amortized O((logN)/B) transfers, matching the bounds for a (cacheaware) buffered repository tree. A partially deamortized COLA matches these bounds but reduces the worstcase insertion cost to O(logN) if memory size M = Ω(logN). We also present a cacheaware version of the COLA, the lookahead array, which achieves the same bounds as Brodal and Fagerberg’s (cacheaware) Bεtree. We compare our COLA implementation to a traditional Btree. Our COLA implementation runs 790 times faster for random insertions, 3.1 times slower for insertions of sorted data, and 3.5 times slower for searches.
Scalable continuous queries processing by tracking hotspots
, 2006
"... Abstract This paper considers the problem of scalably processing a large number of continuous queries.We propose a flexible framework with novel data structures and algorithms for groupprocessing and indexing continuous queries by exploiting potential overlaps in query predicates. Our approachparti ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
Abstract This paper considers the problem of scalably processing a large number of continuous queries.We propose a flexible framework with novel data structures and algorithms for groupprocessing and indexing continuous queries by exploiting potential overlaps in query predicates. Our approachpartitions the collection of continuous queries into groups based on the clustering patterns of the query ranges, and then applies specialized processing strategies to those heavilyclustered groups(or hotspots). To maintain the partition dynamically, we present efficient algorithms that maintain a nearly optimal partition in nearly amortized logarithmic time. We show how to use the hotspotsto scalably process large numbers of continuous selectjoin and bandjoin queries, which are much more challenging than simple range selection queries. Experiments demonstrate that this approachcan improve the processing throughput by orders of magnitude. As another application of hotspots, we show how to use them to build a highquality histogram for intervals in linear time.
Ranksensitive data structures
 In Proc. 12th International Symposium on String Processing and Information Retrieval (SPIRE), LNCS v. 3772
, 2005
"... Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we foc ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we focus on ranksensitive data structures, which are additionally given a ranking of the n items, so that just the top k bestranking items should be reported at query time, sorted in rank order, at a cost of O(t(n) + k) time. Note that k is part of the query as a parameter under the control of the user (as opposed to ℓ which is querydependent). We explore the problem of adding ranksensitivity to data structures such as suffix trees or range trees, where the ℓ items satisfying the query form O(polylog(n)) intervals of consecutive entries from which we choose the top k bestranking ones. Letting s(n) be the number of items (including their copies) stored in the original data structures, we increase the space by an additional term of O(s(n) lg ǫ n) memory words of space, each of O(lg n) bits, for any positive constant ǫ < 1. We allow for changing the ranking on the fly during the lifetime of the data structures, with ranking values in 0... O(n). In this case, query time becomes O(t(n)+k) plus O(lg n/lg lg n) per interval; each change in the ranking and each insertion/deletion of an item takes O(lg n) time; the additional term in space occupancy increases to O(s(n) lg n/lg lg n). 1
An optimal dynamic interval stabbingmax data structure
 In Proc. ACMSIAM Symposium on Discrete Algorithms
, 2005
"... 1 Introduction In this paper we consider data structures for thestabbingmax problem (also sometimes called the rectangle intersection with priorities problem). That is, theproblem of dynamically maintaining a set S of n axisparallel hyperrectangles in Rd, where each rectangle s 2 S has a weight w ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
1 Introduction In this paper we consider data structures for thestabbingmax problem (also sometimes called the rectangle intersection with priorities problem). That is, theproblem of dynamically maintaining a set S of n axisparallel hyperrectangles in Rd, where each rectangle s 2 S has a weight w(s) 2 R, so that the rectangle withthe maximum weight containing a query point can be
Data structures for range median queries
 In Proceedings of the 20th International Symposium on Algorithms and Computation
, 2009
"... Abstract. In this paper we design data structures supporting range median queries, i.e. report the median element in a subrange of an array. We consider static and dynamic data structures and batched queries. Our data structures support range selection queries, which are more general, and dominance ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
Abstract. In this paper we design data structures supporting range median queries, i.e. report the median element in a subrange of an array. We consider static and dynamic data structures and batched queries. Our data structures support range selection queries, which are more general, and dominance queries (range rank). In the static case our data structure uses linear space and queries are supported in O(log n / log log n) time. Our dynamic data structure uses O(n log n / log log n) space and supports queries and updates in O((log n / log log n) 2) time. 1
Optimal external memory planar point enclosure
 In Proc. European Symposium on Algorithms
, 2004
"... Abstract. In this paper we study the external memory planar point enclosure problem: Given N axisparallel rectangles in the plane, construct a data structure on disk (an index) such that all K rectangles containing a query point can be reported I/Oefficiently. This problem has important applicatio ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
Abstract. In this paper we study the external memory planar point enclosure problem: Given N axisparallel rectangles in the plane, construct a data structure on disk (an index) such that all K rectangles containing a query point can be reported I/Oefficiently. This problem has important applications in e.g. spatial and temporal databases, and is dual to the important and wellstudied orthogonal range searching problem. Surprisingly, we show that one cannot construct a linear sized external memory point enclosure data structure that can be used to answer a query in O(log B N + K/B) I/Os, where B is the disk block size. To obtain this bound, Ω(N/B 1−ɛ) disk blocks are needed for some constant ɛ> 0. With linear space, the best obtainable query bound is O(log 2 N + K/B). To show this we prove a general lower bound on the tradeoff between the size of the data structure and its query cost. We also develop a family of structures with matching space and query bounds. 1
Dynamic Planar Range Maxima Queries
 In Proc. 38th International Colloquium on Automata, Languages, and Programming, vol 6755 of LNCS
"... Abstract. We consider the dynamic twodimensional maxima query problem. Let P be a set of n points in the plane. A point is maximal if it is not dominated by any other point in P. We describe two data structures that support the reporting of the t maximal points that dominate a given query point, an ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
Abstract. We consider the dynamic twodimensional maxima query problem. Let P be a set of n points in the plane. A point is maximal if it is not dominated by any other point in P. We describe two data structures that support the reporting of the t maximal points that dominate a given query point, and allow for insertions and deletions of points in P. In the pointer machine model we present a linear space data structure with O(log n + t) worst case query time and O(log n) worst case update time. This is the first dynamic data structure for the planar maxima dominance query problem that achieves these bounds in the worst case. The data structure also supports the more general query of reporting the maximal points among the points that lie in a given 3sided orthogonal range unbounded from above in the same complexity. We can support 4sided queries in O(log 2 n+t) worst case time, and O(log 2 n) worst case update time, using O(n log n) space, where t is the size of the output. This improves the worst case deletion time of the dynamic rectangular visibility query problem from O(log 3 n) to O(log 2 n). We adapt the data structure to the RAM model with word size w, where the coordinates of the points are integers in the range U={0,..., 2 w −1}. We present a linear space data structure that supports 3sided range maxima queries in log n log n O ( +t) worst case time and updates in O ( ) worst case time. log log n log log n These are the first sublogarithmic worst case bounds for all operations in the RAM model. 1
Optimal dynamic vertical ray shooting in rectilinear planar subdivisions
"... Optimal dynamic vertical ray shooting in rectilinear planar subdivisions. In this paper we consider the dynamic vertical ray shooting problem, that is the task of maintaining a dynamic set S of n non intersecting horizontal line segments in the plane subject to a query that reports the first segment ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Optimal dynamic vertical ray shooting in rectilinear planar subdivisions. In this paper we consider the dynamic vertical ray shooting problem, that is the task of maintaining a dynamic set S of n non intersecting horizontal line segments in the plane subject to a query that reports the first segment in S intersecting a vertical ray from a query point. We develop a linearsize structure that supports queries, insertions and deletions in O(log n) worstcase time. Our structure works in the comparison model and uses a RAM.
Towards Optimal Range Medians ⋆
"... Abstract. We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(n log k + k log n) time to answer k such median queries. Th ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Abstract. We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(n log k + k log n) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a comparison lower bound for k = O(n). The space complexity of our simple algorithm is O(n log n) in the pointermachine model, and O(n) in the RAM model. In the latter model, a more involved O(n) space data structure can be constructed in O(n log n) time where the time per query is reduced to O(log n / log log n). We also give efficient dynamic variants of both data structures, achieving O(log 2 n) query time using O(n log n) space in the comparison model and O((log n / log log n) 2) query time using O(n log n / log log n) space in the RAM model, and show that in the cellprobe model, any data structure which supports updates in O(log O(1) n) time must have Ω(log n / log log n) query time.