Fast algorithms for finding nearest common ancestors
SIAM Journal on Computing
Efficient optimal pagination of scrolls
Communications of the ACM
The input/output complexity of sorting and related problems
Communications of the ACM
On finding lowest common ancestors: simplification and parallelization
SIAM Journal on Computing
Recursive star-tree parallel data structure
SIAM Journal on Computing
The string B-tree: a new data structure for string search in external memory and its applications
Journal of the ACM (JACM)
External-memory graph algorithms
Proceedings of the sixth annual ACM-SIAM symposium on Discrete algorithms
Time- and space-optimality in B-trees
ACM Transactions on Database Systems (TODS)
ACM Transactions on Database Systems (TODS)
Journal of Algorithms
ACM Computing Surveys (CSUR)
Optimal pagination of B-trees with variable-length items
Communications of the ACM
Pagination of B*-trees with variable-length records
Communications of the ACM
A new algorithm for the construction of optimal B-trees
Nordic Journal of Computing
LATIN '00 Proceedings of the 4th Latin American Symposium on Theoretical Informatics
Scaling and related techniques for geometry problems
STOC '84 Proceedings of the sixteenth annual ACM symposium on Theory of computing
Cache-oblivious string dictionaries
SODA '06 Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm
Cache-oblivious string B-trees
Proceedings of the twenty-fifth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems
Indexing design considerations
IBM Systems Journal
Hi-index | 0.00 |
Most B-tree 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(logf+1 N) block transfers. When keys have variable size, however, B-tree operations have no nontrivial performance guarantees. This paper provides B-tree-like 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 atomic-key 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 B-tree structure, simply by choosing the pivot keys properly. This paper describes both static and dynamic atomic-key dictionaries. In the static case, if there are N keys with average size K, the search cost is O(⌈K/B⌉ log1+⌈K/B⌉ N) expected transfers. The paper proves that it is not possible to transform these expected bounds into worst-case 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⌉ log1+⌈K/B⌉ N + |κ| /B) transfers. A dynamic-programming algorithm is shown for constructing a search tree with minimal expected cost.