Finger Search Tree Research Articles

Improved Bounds for Finger Search on a RAM

We present a new finger search tree with O(loglogd) expected search time in the Random Access Machine (RAM) model of computation for a large class of input distributions. The parameter d represents the number of elements (distance) between the search element and an element pointed to by a finger, in a finger search tree that stores n elements. Our data structure improves upon a previous result by Andersson and Mattsson that exhibits expected O(loglogn) search time by incorporating the distance d into the search time complexity, and thus removing the dependence on n. We are also able to show that the search time is O(loglogd+ϕ(n)) with high probability, where ϕ(n) is any slowly growing function of n. For the need of the analysis we model the updates by a “balls and bins” combinatorial game that is interesting in its own right as it involves insertions and deletions of balls according to an unknown distribution.

Optimal finger search trees in the pointer machine

We develop a new finger search tree with worst-case constant update time in the pointer machine (PM) model of computation. This was a major problem in the field of Data Structures and was tantalizingly open for over 20 years, while many attempts by researchers were made to solve it. The result comes as a consequence of the innovative mechanism that guides the rebalancing operations, combined with incremental multiple splitting and fusion techniques over nodes.

A Tree-based Mergesort

We demonstrate that if standard Mergesort is implemented using finger search trees instead of arrays it optimally adapts to a set of measures of presortedness not fulfilled by any other algorithm.

A SIMPLE BALANCED SEARCH TREE WITH O(1) WORST-CASE UPDATE TIME

In this paper we show how a slight modification of (a, 2b)-trees allows us to perform member and neighbor queries in O( log n) time and updates in O(1) worst-case time (once the position of the inserted or deleted key is known). Our data structure is quite natural and much simpler than previous worst-case optimal solutions. It is based on two techniques : 1) bucketing, i.e., storing an ordered list of 2 log n keys in each leaf of an (a, 2b) tree, and 2) preventive splitting, i.e., splitting nodes before they can grow bigger than allowed. If only insertions are allowed, it can also be used as a finger search tree with O( log * n) worst-case update time.

A constant update time finger search tree

Levcopolous and Overmars ( Acta Inform., 26 (1988) 269-277) describe a search tree with O(1) worst-case update time, i.e., the time to insert or delete a key is O(1) in the worst case if the position of the key is known. Their data structure does not support fingers, pointers to specific keys such that access and update operations in the vicinity of a finger are especially efficient. We modify their data structure to support fingers while still maintaining O(1) worst-case update time, partially improving upon an earlier result of Harel (University of California, Davis, TR #154, 1980) who achieved O(log * n) worst-case update time in a search tree with fingers. Our data structure uses the random-access machine (RAM) model with unit-cost measure and logarithmic word size; the data structures of Levcopolous and Overmars and Harel use the weaker pointer machine model.