scholarly journals External-Storage Data Structures for Plane-Sweep Algorithms

1994 ◽  
Vol 1 (16) ◽  
Author(s):  
Lars Arge
Keyword(s):  
Data Structure ◽  
Data Structures ◽  
Priority Queue ◽  
Optimal Number ◽  
Range Searching ◽  
Dynamic Data ◽  
Plane Sweep ◽  
Internal Memory ◽  
Segment Tree ◽  
Range Tree

In this paper we develop a technique for transforming an internal memory datastructure into an external storage data structure suitable for plane-sweep algorithms. We use this technique to develop external storage versions of the range tree and the segment tree. We also obtain an external priority queue. Using the first two structures, we solve the orthogonal segment intersection, the isothetic rectangle intersection, and the batched range searching problem in the optimal number of I/O-operations. Unlike previously known I/O-algorithms the developed algorithms are straightforward generalizations of the ordinary internal memory plane-sweep algorithms. Previously almost no dynamic data structures were known for the model we are working in.

scholarly journals The Buffer Tree: A New Technique for Optimal I/O Algorithms

1996 ◽  
Vol 3 (28) ◽  
Author(s):  
Lars Arge
Keyword(s):  
Practical Interest ◽  
Priority Queue ◽  
Search Tree ◽  
Asymptotic Bounds ◽  
Internal Memory ◽  
External Data ◽  
Segment Tree ◽  
Range Tree ◽  
A New Technique ◽  
Tree Data Structure

In this paper we develop a technique for transforming an internal-memory tree data structure into an external-memory structure. We show how the technique can be used to develop a search tree like structure, a priority queue, a (one-dimensional) range tree and a segment tree, and give examples of how these structures can be used to develop efficient I/O algorithms. All our algorithms are either extremely simple or straightforward generalizations of known internal-memory algorithms - given the developed external data structures. We believe that algorithms relying on the developed structure will be of practical interest due to relatively small constants in the asymptotic bounds.

scholarly journals MERGEABLE DOUBLE-ENDED PRIORITY QUEUES

1999 ◽  
Vol 10 (01) ◽  
pp. 1-17 ◽  
Author(s):  
SEONGHUN CHO ◽  
SARTAJ SAHNI
Keyword(s):  
Data Structure ◽  
Data Structures ◽  
Priority Queue ◽  
Priority Queues ◽  
Experimental Results ◽  
Tree Data ◽  
Tree Data Structure

We show that the leftist tree data structure may be adapted to obtain data structures that permit the double-ended priority queue operations Insert, DeleteMin, DeleteMax, and Merge to be done in O( log n) time where n is the size of the resulting queue. The operations FindMin and FindMax can be done in O(1) time. Experimental results are also presented.

scholarly journals Query co-planning for shared execution in key-value stores

2021 ◽  
Vol 12 (5) ◽  
Author(s):  
Josué Ttito ◽  
Renato Marroquín ◽  
Sergio Lifschitz ◽  
Lewis McGibbney ◽  
José Talavera
Keyword(s):  
Data Structure ◽  
Data Structures ◽  
Data Model ◽  
Range Queries ◽  
Model Data ◽  
Data Movement ◽  
Segment Tree ◽  
Interval Tree ◽  
Simple Interface ◽  
Arbitrary Objects

Key-value stores propose a straightforward yet powerful data model. Data is modeled using key-value pairs where values can be arbitrary objects and written/read using the key associated with it. In addition to their simple interface, such data stores also provide read operations such as full and range scans. However, due to the simplicity of its interface, trying to optimize data accesses becomes challenging. This work aims to enable the shared execution of concurrent range and point queries on key-value stores. Thus, reducing the overall data movement when executing a complete workload. To accomplish this, we analyze different possible data structures and propose our variation of a segment tree, Updatable Interval Tree. Our data structure helps us co-planning and co-executing multiple range queries together and reduces redundant work. This results in executing workloads more efficiently and overall increased throughput, as we show in our evaluation.

FAST AND EFFICIENT OPERATIONS ON PARALLEL PRIORITY QUEUES

1996 ◽  
Vol 06 (04) ◽  
pp. 451-467
Author(s):  
DANNY Z. CHEN ◽  
XIAOBO SHARON HU
Keyword(s):  
Data Structure ◽  
Parallel Algorithms ◽  
Computational Model ◽  
Data Structures ◽  
Priority Queue ◽  
Minimal Path ◽  
Erew Pram ◽  
New Ideas ◽  
The Right ◽  
Path Partition

The Parallel Priority Queue (PPQ) data structure supports parallel operations for manipulating data items with keys, such as inserting n new items, deleting n items with the first n smallest keys, creating a new PPQ that contains a set of items, and melding two PPQ’s into one. In this paper, we present fast and efficient parallel algorithms for performing operations on the PPQ’s that maintain data items with real-valued keys. The data structures that we use for implementing the PPQ’s are the unmeldable and meldable parallel heaps. Our algorithms have considerably less time and/or work bounds than the previously best known algorithms, and use a less powerful parallel computational model (EREW PRAM). The new ideas that make our improvement possible are two partition schemes dynamically maintained on the parallel heap structures: the minimal- path partition and the right-path partition. These partition schemes could be of interest in their own right. Our results also lead to optimal parallel algorithms for implementing sequential operations on several commonly-used heap structures.

SKIP QUADTREES: DYNAMIC DATA STRUCTURES FOR MULTIDIMENSIONAL POINT SETS

2008 ◽  
Vol 18 (01n02) ◽  
pp. 131-160 ◽  
Author(s):  
DAVID EPPSTEIN ◽  
MICHAEL T. GOODRICH ◽  
JONATHAN Z. SUN
Keyword(s):  
Data Structure ◽  
Hierarchical Structure ◽  
Data Structures ◽  
Nearest Neighbor ◽  
Point Location ◽  
Dynamic Data ◽  
Higher Dimensional ◽  
Point Data ◽  
Logarithmic Height ◽  
Nearest Neighbor Queries

We present a new multi-dimensional data structure, which we call the skip quadtree (for point data in R2) or the skip octree (for point data in Rd, with constant d > 2). Our data structure combines the best features of two well-known data structures, in that it has the well-defined “box”-shaped regions of region quadtrees and the logarithmic-height search and update hierarchical structure of skip lists. Indeed, the bottom level of our structure is exactly a region quadtree (or octree for higher dimensional data). We describe efficient algorithms for inserting and deleting points in a skip quadtree, as well as fast methods for performing point location, approximate range, and approximate nearest neighbor queries.

scholarly journals Query co-planning for shared execution in Key-Value Stores

2020 ◽  
Author(s):  
Josue Joel Ttito ◽  
Renato Marroquin ◽  
Sergio Lifschitz
Keyword(s):  
Data Structure ◽  
Data Structures ◽  
Data Model ◽  
Range Queries ◽  
Model Data ◽  
Data Movement ◽  
Segment Tree ◽  
Interval Tree ◽  
Simple Interface ◽  
Arbitrary Objects

Key-value stores propose a very simple yet powerful data model. Data is modeled using key-value pairs where values can be arbitrary objects and can be written/read using the key associated with it. In addition to their simple interface, such data stores also provide read operations such as full and range scans. However, due to the simplicity of its interface, trying to optimize data accesses becomes challenging. This work aims to enable the shared execution of concurrent range and point queries on key-value stores. Thus, reducing the overall data movement when executing a complete workload. To accomplish this, we analyze different possible data structures and propose our variation of a segment tree, Updatable Interval Tree. This data structure helps us co-planning and co-executing multiple range queries together, as we show in our evaluation.

Explaining binomial heaps

1999 ◽  
Vol 9 (1) ◽  
pp. 93-104 ◽  
Author(s):  
RALF HINZE
Keyword(s):  
Data Structure ◽  
Programming Languages ◽  
Data Structures ◽  
Functional Programming ◽  
Priority Queue ◽  
Algorithms And Data Structures ◽  
Functional Programming Languages ◽  
Reading And Writing ◽  
Type Classes ◽  
Excellent Tool

Functional programming languages are an excellent tool for teaching algorithms and data structures. This paper explains binomial heaps, a beautiful data structure for priority queues, using the functional programming language Haskell (Peterson and Hammond, 1997). We largely follow a deductive approach: using the metaphor of a tennis tournament we show that binomial heaps arise naturally through a number of logical steps. Haskell supports the deductive style of presentation very well: new types are introduced at ease, algorithms can be expressed clearly and succinctly, and Haskell's type classes allow to capture common algorithmic patterns. The paper aims at the level of an undergraduate student who has experience in reading and writing Haskell programs, and who is familiar with the concept of a priority queue.

scholarly journals Implementing generalized deep-copy in MPI

2016 ◽  
Vol 2 ◽  
pp. e95
Author(s):  
Joss Whittle ◽  
Rita Borgo ◽  
Mark W. Jones
Keyword(s):  
Data Structure ◽  
Data Structures ◽  
Source Code ◽  
Structured Data ◽  
Complete Graphs ◽  
Complex Dynamic ◽  
Dynamic Data ◽  
Implementation Problem ◽  
Dynamic Data Structure ◽  
Programming Interface

In this paper, we introduce a framework for implementing deep copy on top of MPI. The process is initiated by passing just the root object of the dynamic data structure. Our framework takes care of all pointer traversal, communication, copying and reconstruction on receiving nodes. The benefit of our approach is that MPI users can deep copy complex dynamic data structures without the need to write bespoke communication or serialize/deserialize methods for each object. These methods can present a challenging implementation problem that can quickly become unwieldy to maintain when working with complex structured data. This paper demonstrates our generic implementation, which encapsulates both approaches. We analyze the approach with a variety of structures (trees, graphs (including complete graphs) and rings) and demonstrate that it performs comparably to hand written implementations, using a vastly simplified programming interface. We make the source code available completely as a convenient header file.

Sign in / Sign up

Export Citation Format

Share Document