Results 1 
6 of
6
Data Structural Bootstrapping, Linear Path Compression, and Catenable Heap Ordered Double Ended Queues
 SIAM Journal on Computing
, 1992
"... A deque with heap order is a linear list of elements with realvalued keys which allows insertions and deletions of elements at both ends of the list. It also allows the findmin (equivalently findmax) operation, which returns the element of least (greatest) key, but it does not allow a general delet ..."
Abstract

Cited by 15 (7 self)
 Add to MetaCart
A deque with heap order is a linear list of elements with realvalued keys which allows insertions and deletions of elements at both ends of the list. It also allows the findmin (equivalently findmax) operation, which returns the element of least (greatest) key, but it does not allow a general deletemin (deletemax) operation. Such a data structure is also called a mindeque (maxdeque) . Whereas implementing mindeques in constant time per operation is a solved problem, catenating mindeques in sublogarithmic time has until now remained open. This paper provides an efficient implementation of catenable mindeques, yielding constant amortized time per operation. The important algorithmic technique employed is an idea which is best described as data structural bootstrapping: We abstract mindeques so that their elements represent other mindeques, effecting catenation while preserving heap order. The efficiency of the resulting data structure depends upon the complexity of a special case of pa...
Efficient Optimal Pagination of Scrolls
 COMMUNICATIONS OF THE ACM
, 1985
"... Diehr and Faaland developed an algorithm that finds the minimum sum of key length pagination of a scroll of n items, and which uses O(n lg n) time and O(n) space, solving a problem posed by McCreight. An improved algorithm is given which uses O(n) time and O(n) space. ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Diehr and Faaland developed an algorithm that finds the minimum sum of key length pagination of a scroll of n items, and which uses O(n lg n) time and O(n) space, solving a problem posed by McCreight. An improved algorithm is given which uses O(n) time and O(n) space.
New Applications of Failure Functions
 JOURNAL OF THE ASSOCIATION FOR COMPUTING MACHINERY
, 1987
"... Several algorithms are presented whose operations are governed by a principle of failure functions: when searching for an extremal value within a sequence, it suffices to consider only the subsequence of items each of which is the first possible improvement of its predecessor. These algorithms are m ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Several algorithms are presented whose operations are governed by a principle of failure functions: when searching for an extremal value within a sequence, it suffices to consider only the subsequence of items each of which is the first possible improvement of its predecessor. These algorithms are more efficient than their more traditional counterparts.
Analysis of Overflow Handling for Variable Length Records
 INFORMATION SYSTEMS
, 1989
"... Although files with variable length records are very frequent in actual databases due to variable length fields, missing attribute values, multiple values of an attribute and compression, little has been reported in the literature about file structures appropriate for variable length records. In thi ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Although files with variable length records are very frequent in actual databases due to variable length fields, missing attribute values, multiple values of an attribute and compression, little has been reported in the literature about file structures appropriate for variable length records. In this paper we describe and analyze several overflow handling techniques for the case when records are of variable length. We develop analytic models that take into account variable length records and study the performance in the context of indexed sequential (ISAM) files. We also propose a new overflow handling technique and show that it provides an incremental reorganization capability appropriate for handling variable length records. Analytic results demonstrate that its performance is better than the performance of previous methods, The overflow handling techniques and the analytic methods developed in this paper are also applicable to other file structures with variable length records that require overtlow handling.
Asynchronous Generic Key/Value Database
"... BTrees are ideal structures for building databases with fixedsize keys, and have been successfully extended in a variety of ways to accomodate specific key distributions; however, in the general case in which the key distribution either is unknown beforehand or is intentionally pathological, even ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
BTrees are ideal structures for building databases with fixedsize keys, and have been successfully extended in a variety of ways to accomodate specific key distributions; however, in the general case in which the key distribution either is unknown beforehand or is intentionally pathological, even the most timehonored BTree variants  such as prefixcompressed trees  provide suboptimal performance; e.g., Sleepycat's poor performance on key distributions with many large keys. Insufficient generality in dealing with different key distributions makes most BTree variants unsuitable for general applications such as file systems. Furthermore, implementations of BTrees are often limited to either preemptive or cooperative multithreaded operation with synchronous I/O primitives: the overhead caused by lock contention and multiple stacks makes this an insufficient solution for highlyparallel tasks. This thesis helps fill the void in these areas by introducing and analyzing the performance of a C++ implementation of the String BTree of Ferragina and Rossi that meets certain efficiency and exibility constraints  such as operating within typical B+ Tree time bounds and providing good performance on long arbitrarilydistributed keys  while requiring only asynchronous I/O primitives.
Performance guarantees for Btrees . . .
, 2010
"... Most Btree papers assume that all N keys have the same size K, that f = B/K keys fit in a disk block, and therefore that the search cost is O(log f+1 N) block transfers. When keys have variable size, however, Btree operations have no nontrivial performance guarantees. This paper provides Btreeli ..."
Abstract
 Add to MetaCart
Most Btree papers assume that all N keys have the same size K, that f = B/K keys fit in a disk block, and therefore that the search cost is O(log f+1 N) block transfers. When keys have variable size, however, Btree operations have no nontrivial performance guarantees. This paper provides Btreelike performance guarantees on dictionaries that contain keys of different sizes in a model in which keys must be stored and compared as opaque objects. The resulting atomickey dictionaries exhibit performance bounds in terms of the average key size and match the bounds when all keys are the same size. Atomic key dictionaries can be built with minimal modification to the Btree structure, simply by choosing the pivot keys properly. This paper describes both static and dynamic atomickey dictionaries. In the static case, if there are N keys with average size K, the search cost is O(⌈K/B ⌉ log 1+⌈B/K ⌉ N) expected transfers. The paper proves that it is not possible to transform these expected bounds into worstcase bounds. The cost to build the tree is O(NK) operations and O(NK/B) transfers if all keys are presented in sorted order. If not, the cost is the sorting cost. For the dynamic dictionaries, the amortized cost to insert a key κ of arbitrary length at an arbitrary rank is dominated by the cost to search for κ. Specifically the amortized cost to insert a key κ of arbitrary length and random rank is O(⌈K/B ⌉ log 1+⌈B/K ⌉ N + κ  /B) transfers. A dynamicprogramming algorithm is shown for constructing a search tree with minimal expected cost.