Results 1  10
of
15
On Rotations and the Generation of Binary Trees
 J. Algorithms
, 1993
"... The rotation graph, G n , has vertex set consisting of all binary trees with n nodes. Two vertices are connected by an edge if a single rotation will transform one tree into the other. We provide a simpler proof of a result of Lucas [7] that G n contains a Hamilton path. Our proof deals directly wi ..."
Abstract

Cited by 39 (6 self)
 Add to MetaCart
The rotation graph, G n , has vertex set consisting of all binary trees with n nodes. Two vertices are connected by an edge if a single rotation will transform one tree into the other. We provide a simpler proof of a result of Lucas [7] that G n contains a Hamilton path. Our proof deals directly with the pointer representation of the binary tree. This proof provides the basis of an algorithm for generating all binary trees that can be implemented to run on a pointer machine and to use only constant time between the output of successive trees. Ranking and unranking algorithms are developed for the ordering of binary trees implied by the generation algorithm. These algorithms have time complexity O(n 2 ) (arithmetic operations). We also show strong relationships amongst various representations of binary trees and amongst binary tree generation algorithms that have recently appeared in the literature. Current address: SUNY Brockport, Mathematics & Computer Science Dept., Brockport, ...
SelfOrganizing Data Structures
 In
, 1998
"... . We survey results on selforganizing data structures for the search problem and concentrate on two very popular structures: the unsorted linear list, and the binary search tree. For the problem of maintaining unsorted lists, also known as the list update problem, we present results on the competit ..."
Abstract

Cited by 22 (0 self)
 Add to MetaCart
. We survey results on selforganizing data structures for the search problem and concentrate on two very popular structures: the unsorted linear list, and the binary search tree. For the problem of maintaining unsorted lists, also known as the list update problem, we present results on the competitiveness achieved by deterministic and randomized online algorithms. For binary search trees, we present results for both online and offline algorithms. Selforganizing data structures can be used to build very effective data compression schemes. We summarize theoretical and experimental results. 1 Introduction This paper surveys results in the design and analysis of selforganizing data structures for the search problem. The general search problem in pointer data structures can be phrased as follows. The elements of a set are stored in a collection of nodes. Each node also contains O(1) pointers to other nodes and additional state data which can be used for navigation and selforganizati...
Splay trees, DavenportSchinzel sequences, and the deque conjecture
"... We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence, none of whose subsequences are isomorphic to a fixed forbidden subsequence. We direct ..."
Abstract

Cited by 18 (6 self)
 Add to MetaCart
(Show Context)
We introduce a new technique to bound the asymptotic performance of splay trees. The basic idea is to transcribe, in an indirect fashion, the rotations performed by the splay tree as a DavenportSchinzel sequence, none of whose subsequences are isomorphic to a fixed forbidden subsequence. We direct this technique towards Tarjan’s deque conjecture and prove that n deque operations take only O(nα ∗ (n)) time, where α ∗ (n) is the minimum number of applications of the inverseAckermann function mapping n to a constant. We are optimistic that this approach could be directed towards other open conjectures on splay trees such as the traversal and split conjectures.
Randomized splay trees: theoretical and experimental results
 Information Processing Letters
"... Abstract Splay trees are selforganizing binary search trees that were introduced by Sleator andTarjan [12]. In this paper we present a randomized variant of these trees. The new algorithm for reorganizing the tree is both simple and easy to implement. We prove that our randomizedsplaying scheme has ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
(Show Context)
Abstract Splay trees are selforganizing binary search trees that were introduced by Sleator andTarjan [12]. In this paper we present a randomized variant of these trees. The new algorithm for reorganizing the tree is both simple and easy to implement. We prove that our randomizedsplaying scheme has the same asymptotic performance as the original deterministic scheme but improves constants in the expected running time. This is interesting in practice becausethe search time in splay trees is typically higher than the search time in skip lists and AVLtrees. We present a detailed experimental study of our algorithm. On request sequencesgenerated by fixed probability distributions, we can achieve improvements of up to 25 % over deterministic splaying. On request sequences that exhibit high locality of reference, theimprovements are minor.
Dynamic optimality and multisplay trees
, 2004
"... The Dynamic Optimality Conjecture [ST85] states that splay trees are competitive (with a constant competitive factor) among the class of all binary search tree (BST) algorithms. Despite 20 years of research this conjecture is still unresolved. Recently Demaine et al. [DHIP04] suggested searching for ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
The Dynamic Optimality Conjecture [ST85] states that splay trees are competitive (with a constant competitive factor) among the class of all binary search tree (BST) algorithms. Despite 20 years of research this conjecture is still unresolved. Recently Demaine et al. [DHIP04] suggested searching for alternative algorithms which have small, but nonconstant competitive factors. They proposed tango, a BST algorithm which is nearly dynamically optimal – its competitive ratio is £¥¤§¦©¨���¦�¨����� � instead of a constant. Unfortunately, for many access patterns, tango is worse than other BST algorithms by a factor of ¦�¨���¦�¨��� �. In this paper we introduce multisplay trees, which can be viewed as a variant of splay trees. We prove the multisplay access lemma, which resembles the access lemma for splay trees. With different assignment of weights, this lemma allows us to prove various bounds on the performance of multisplay trees. Specifically, we prove that multisplay trees are £¥¤�¦�¨���¦©¨����� �competitive, and amortized £¥¤�¦�¨����� �. This is the first BST data structure to simultaneously achieve these two bounds. In addition, the algorithm is simple enough that we include code for its key parts. This work raises many open questions about the performance of multisplay trees. Does sequential access take linear time? (Our experiments indicate the answer is “yes”.) Are multisplay trees dynamically optimal? How do multisplay trees compare to splay trees? Specifically, are there sequences where one outperformes the other? What can be proved if we allow insertions and deletions in a multisplay tree? 1
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
KIST: A new encryption algorithm based on splay
"... In this paper, we proposed a new encryption algorithm called KIST. This algorithm uses an asynchronous key sequence and a splay tree. It is very efficient in the usage of both space and time. Some elementary security tests have been done. Key words asynchronous key sequence, splay tree, symmetric ke ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
In this paper, we proposed a new encryption algorithm called KIST. This algorithm uses an asynchronous key sequence and a splay tree. It is very efficient in the usage of both space and time. Some elementary security tests have been done. Key words asynchronous key sequence, splay tree, symmetric key encryption 1
unknown title
, 2012
"... In the next two lectures we study the question of dynamic optimality, or whether there exists a binary search tree algorithm that performs ”as well ” as all other algorithms on any input string. In this lecture we will define a binary search tree as a formal model of computation, show some analytic ..."
Abstract
 Add to MetaCart
(Show Context)
In the next two lectures we study the question of dynamic optimality, or whether there exists a binary search tree algorithm that performs ”as well ” as all other algorithms on any input string. In this lecture we will define a binary search tree as a formal model of computation, show some analytic bounds that a dynamically optimal binary search tree needs to satisfy, and show two search trees that are conjectured to be dynamically optimal. The first is the splay tree, which we will cover only briefly. The second will require us to build up a geometric view of a sequence of binary search tree queries. 2 Binary Search Trees The question we will explore in this lecture is whether or not there is a ”best ” binary search tree. We know that there are selfbalancing binary search trees that take O(logn) per query. Can we do better? In order to explore this question, we need a more rigorous definition of binary search tree. In this lecture we will treat the binary search tree (BST) as a model of computation that is a subset of the pointer machine model of computation. 2.1 Model of Computation A BST can be viewed is a model of computation where data must be stored as keys in a binary search tree. Each key has a pointer to its parent (unless it is the root) and a pointer to its left and right children, or a null pointer if they do not exist. The value of the key stored in the left child of a node must be less than or equal to the value of the key stored at the node, which is in turn less than or equal to the value of the key stored at the right child. The model supports the following unitcost operations: • Walk to left child. • Walk to right child. • Walk to parent. • Rotate node x. 1 a b x c p
Abstract O(log log n)Competitive Dynamic Binary Search Trees ∗
"... splay trees are competitive (within a constant competitive factor) among the class of all binary search tree (BST) algorithms. Despite 20 years of research this conjecture is still unresolved. Recently, Demaine et al. [DHIP04] suggested searching for alternative algorithms which have small but nonc ..."
Abstract
 Add to MetaCart
splay trees are competitive (within a constant competitive factor) among the class of all binary search tree (BST) algorithms. Despite 20 years of research this conjecture is still unresolved. Recently, Demaine et al. [DHIP04] suggested searching for alternative algorithms which have small but nonconstant competitive factors. They proposed Tango, a BST algorithm which is nearly dynamically optimal – its competitive ratio is O(log log n) instead of a constant. Unfortunately, for many access patterns, such as random and sequential, Tango is worse than other BST algorithms by a factor of log log n. In this paper, we introduce the multisplay tree (MST) data structure, which is the first O(log log n)competitive BST to simultaneously achieve O(log n) amortized cost and O(log 2 n) worstcase cost per query. We also prove the sequential access lemma for MSTs, which states that sequentially accessing all keys takes linear time. Thus, MSTs are O(log log n)competitive like Tango but, unlike Tango, require only O(log n) amortized time per access in an arbitrary sequence and only O(1) amortized time per access during a sequential access sequence. Furthermore, we generalize the standard framework for competitive analysis of BST algorithms to include updates (insertions and deletions) in addition to queries. In doing so, we extend the lower bound of Wilber [Wil89] and Demaine et al. [DHIP04] to handle these update operations. We show how MSTs can be modified to support these update operations and be O(log log n)competitive in the new framework while maintaining the rest of the properties above.
Lecture Note 03 CSE4101/5101 SPLAY TREES: SelfAdjusting Binary Search Trees
"... the dictionary abstract data type, called a splay tree, aselfadjusting version of binary search trees. A selfadjusting BST is a BST maintained in a particular way. Throughout this handout, m denotes the number of dictionary operations (INSERT, DELETE or SEARCH) that are processed and n ( ≤ m) ist ..."
Abstract
 Add to MetaCart
the dictionary abstract data type, called a splay tree, aselfadjusting version of binary search trees. A selfadjusting BST is a BST maintained in a particular way. Throughout this handout, m denotes the number of dictionary operations (INSERT, DELETE or SEARCH) that are processed and n ( ≤ m) isthe maximum number of keys inthe dictionary at any time. In balanced BSTs (e.g. redblack trees) we are very careful to maintain the BST heightbalanced at all times. This ensures that the tree will have height at most O(lg n). Since each operation takes time at most proportional to the height of the tree, each individual operation takes at most O(lg n) time. The time needed to process m operations is therefore O(mlgn). Selfadjusting trees have the interesting property that they achieve the same time bound, ev en though it is not the case that each individual operation takes O(lg n) time. Some take more (in fact, some may take aslong as Θ(n)) and some take less, so that the overall time complexity comes to O(mlgn). We cannot hope to derive this bound simply by obtaining an upper bound for the worstcase time complexity of each individual operation and multiplying that bound by the number of operations performed: Since some operations may take aslong as Θ(n) time, this