Results 1 
9 of
9
A Simple Balanced Search Tree With O(1) WorstCase Update Time
"... In this paper we show how a slight modification of (a; b)trees allows us to perform member and neighbor queries in O(log n) time and updates in O(1) worstcase time (once the position of the inserted or deleted key is known). Our data structure is quite natural and much simpler than previous worst ..."
Abstract

Cited by 23 (0 self)
 Add to MetaCart
In this paper we show how a slight modification of (a; b)trees allows us to perform member and neighbor queries in O(log n) time and updates in O(1) worstcase time (once the position of the inserted or deleted key is known). Our data structure is quite natural and much simpler than previous worstcase 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; b) tree, and 2) lazy splitting, i.e. postponing necessary splits of big nodes until we have time to handle them. It can also be used as a finger tree with O(log n) worstcase update time. 1 . Introduction One of the most common (and most important) data structures used in efficient algorithms is the balanced search tree. Hence there exists a great variety of them in literature. Basically, they all store a set of n keys such that location, insertion and deletion of keys can be accomplished in O(log n) worstcase time. In general, updates (insertions or ...
Finger Search Trees with Constant Insertion Time
 In Proc. 9th Annual ACMSIAM Symposium on Discrete Algorithms
, 1997
"... We consider the problem of implementing finger search trees on the pointer machine, i.e., how to maintain a sorted list such that searching for an element x, starting the search at any arbitrary element f in the list, only requires logarithmic time in the distance between x and f in the list. We pr ..."
Abstract

Cited by 14 (3 self)
 Add to MetaCart
(Show Context)
We consider the problem of implementing finger search trees on the pointer machine, i.e., how to maintain a sorted list such that searching for an element x, starting the search at any arbitrary element f in the list, only requires logarithmic time in the distance between x and f in the list. We present the first pointerbased implementation of finger search trees allowing new elements to be inserted at any arbitrary position in the list in worst case constant time. Previously, the best known insertion time on the pointer machine was O(log n), where n is the total length of the list. On a unitcost RAM, a constant insertion time has been achieved by Dietz and Raman by using standard techniques of packing small problem sizes into a constant number of machine words. Deletion of a list element is supported in O(log n) time, which matches the previous best bounds. Our data structure requires linear space. 1 Introduction A finger search tree is a data structure which stores a sorte...
Optimal Finger Search Trees in the Pointer Machine
, 2002
"... 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 twenty years, while many attempts by researchers were made to solve it. The result c ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
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 twenty 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.
Finger Search Trees
, 2005
"... One of the most studied problems in computer science is the problem of maintaining a sorted sequence of elements to facilitate efficient searches. The prominent solution to the problem is to organize the sorted sequence as a balanced search tree, enabling insertions, deletions and searches in logari ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
One of the most studied problems in computer science is the problem of maintaining a sorted sequence of elements to facilitate efficient searches. The prominent solution to the problem is to organize the sorted sequence as a balanced search tree, enabling insertions, deletions and searches in logarithmic time. Many different search trees have been developed and studied intensively in the literature. A discussion of balanced binary search trees can e.g. be found in [4]. This chapter is devoted to finger search trees which are search trees supporting fingers, i.e. pointers, to elements in the search trees and supporting efficient updates and searches in the vicinity of the fingers. If the sorted sequence is a static set of n elements then a simple and space efficient representation is a sorted array. Searches can be performed by binary search using 1+⌊log n⌋ comparisons (we throughout this chapter let log x denote log 2 max{2, x}). A finger search starting at a particular element of the array can be performed by an exponential search by inspecting elements at distance 2 i − 1 from the finger for increasing i followed by a binary search in a range of 2 ⌊log d ⌋ − 1 elements, where d is the rank difference in the sequence between the finger and the search element. In Figure 11.1 is shown an exponential search for the element 42 starting at 5. In the example d = 20. An exponential search requires
MultiSplay Trees
, 2006
"... In this thesis, we introduce a new binary search tree data structure called multisplay tree and prove that multisplay trees have most of the useful properties different binary search trees (BSTs) have. First, we demonstrate a close variant of the splay tree access lemma [ST85] for multisplay tree ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
In this thesis, we introduce a new binary search tree data structure called multisplay tree and prove that multisplay trees have most of the useful properties different binary search trees (BSTs) have. First, we demonstrate a close variant of the splay tree access lemma [ST85] for multisplay trees, a lemma that implies multisplay trees have the O(log n) runtime property, the static finger property, and the static optimality property. Then, we extend the access lemma by showing the remassing lemma, which is similar to the reweighting lemma for splay trees [Geo04]. The remassing lemma shows that multisplay trees satisfy the working set property and keyindependent optimality, and multisplay trees are competitive to parametrically balanced trees, as defined in [Geo04]. Furthermore, we also prove that multisplay trees achieve the O(log log n)competitiveness and that sequential access in multisplay trees costs O(n). Then we naturally extend the static model to allow insertions and deletions and show how to carry out these operations in multisplay trees to achieve
Properties of MultiSplay Trees
, 2009
"... We show that multisplay trees have most of the properties that splay trees have. Specifically, we show that multisplay trees have the following properties: the access lemma, static optimality, the static finger property, the working set property, and keyindependent optimality. Moreover, we prove ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
We show that multisplay trees have most of the properties that splay trees have. Specifically, we show that multisplay trees have the following properties: the access lemma, static optimality, the static finger property, the working set property, and keyindependent optimality. Moreover, we prove that multisplay trees have the deque property, which was conjectured by Tarjan in 1985 for splay trees, but remains unproven despite a significant amount of research toward proving it. Efficiently maintaining and manipulating sets of elements from a totally ordered universe is a fundamental problem in computer science. Specifically, many algorithms need a data structure that can efficiently support at least the following operations: insert, delete, predecessor, and successor, as well as membership testing. A standard data structure that maintains a totally ordered set and
International Journal of Foundations of Computer Science c ○ World Scientific Publishing Company A SIMPLE BALANCED SEARCH TREE WITH O(1) WORSTCASE UPDATE TIME
"... Communicated by Editor’s name 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) worstcase time (once the position of the inserted or deleted key is known). Our data structure is quite natural and mu ..."
Abstract
 Add to MetaCart
Communicated by Editor’s name 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) worstcase time (once the position of the inserted or deleted key is known). Our data structure is quite natural and much simpler than previous worstcase optimal solutions. It is based on two techniques: 1) bucketing, i.e., storing an ordered list of 2log 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) worstcase update time.
Improving the Performance of Multidimensional Search Using Fingers
"... We propose two variants of Kd trees where fingers are used to improve the performance of orthogonal range search and nearest neighbor queries when they exhibit locality of reference. The experiments show that the second alternative yields significant savings. Although it yields more modest improvem ..."
Abstract
 Add to MetaCart
We propose two variants of Kd trees where fingers are used to improve the performance of orthogonal range search and nearest neighbor queries when they exhibit locality of reference. The experiments show that the second alternative yields significant savings. Although it yields more modest improvements, the first variant does it with much less memory requirements and great simplicity, which makes it more attractive on practical grounds.