Results 1  10
of
11
The geometry of binary search trees
 In Proceedings of the 20th ACMSIAM Symposium on Discrete Algorithms (SODA 2009
, 2009
"... We present a novel connection between binary search trees (BSTs) and points in the plane satisfying a simple property. Using this correspondence, we achieve the following results: 1. A surprisingly clean restatement in geometric terms of many results and conjectures relating to BSTs and dynamic opti ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
We present a novel connection between binary search trees (BSTs) and points in the plane satisfying a simple property. Using this correspondence, we achieve the following results: 1. A surprisingly clean restatement in geometric terms of many results and conjectures relating to BSTs and dynamic optimality. 2. A new lower bound for searching in the BST model, which subsumes the previous two known bounds of Wilber [FOCS’86]. 3. The first proposal for dynamic optimality not based on splay trees. A natural greedy but offline algorithm was presented by Lucas [1988], and independently by Munro [2000], and was conjectured to be an (additive) approximation of the best binary search tree. We show that there exists an equalcost online algorithm, transforming the conjecture of Lucas and Munro into the conjecture that the greedy algorithm is dynamically optimal. 1
Dynamic Optimality for Skip Lists and BTrees
, 2008
"... Sleator and Tarjan [39] conjectured that splay trees are dynamically optimal binary search trees (BST). In this context, we study the skip list data structure introduced by Pugh [35]. We prove that for a class of skip lists that satisfy a weak balancing property, the workingset bound is a lower bou ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
Sleator and Tarjan [39] conjectured that splay trees are dynamically optimal binary search trees (BST). In this context, we study the skip list data structure introduced by Pugh [35]. We prove that for a class of skip lists that satisfy a weak balancing property, the workingset bound is a lower bound on the time to access any sequence. Furthermore, we develop a deterministic selfadjusting skip list whose running time matches the workingset bound, thereby achieving dynamic optimality in this class. Finally, we highlight the implications our bounds for skip lists have on multiway branching search trees such as Btrees, (ab)trees, and other variants as well as their binary tree representations. In particular, we show a selfadjusting Btree that is dynamically optimal both in internal and external memory.
SkipSplay: Toward Achieving the Unified Bound in the BST Model
"... Abstract. We present skipsplay, the first binary search tree algorithm known to have a running time that nearly achieves the unified bound. Skipsplay trees require only O(m lg lg n + UB(σ)) time to execute a query sequence σ = σ1...σm. The skipsplay algorithm is simple and similar to the splay al ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Abstract. We present skipsplay, the first binary search tree algorithm known to have a running time that nearly achieves the unified bound. Skipsplay trees require only O(m lg lg n + UB(σ)) time to execute a query sequence σ = σ1...σm. The skipsplay algorithm is simple and similar to the splay algorithm. 1 Introduction and Related Work Although the worstcase access cost for comparisonbased dictionaries is Ω(lg n), many sequences of operations are highly nonrandom, allowing tighter, instancespecific running time bounds to be achieved by algorithms that adapt to the input sequence. Splay trees [1] are an example of such an adaptive algorithm
Upper Bounds for Maximally Greedy Binary Search Trees
"... Abstract. At SODA 2009, Demaine et al. presented a novel connection between binary search trees (BSTs) and subsets of points on the plane. This connection was independently discovered by Derryberry et al. As part of their results, Demaine et al. considered GreedyFuture, an offline BST algorithm that ..."
Abstract
 Add to MetaCart
Abstract. At SODA 2009, Demaine et al. presented a novel connection between binary search trees (BSTs) and subsets of points on the plane. This connection was independently discovered by Derryberry et al. As part of their results, Demaine et al. considered GreedyFuture, an offline BST algorithm that greedily rearranges the search path to minimize the cost of future searches. They showed that GreedyFuture is actually an online algorithm in their geometric view, and that there is a way to turn GreedyFuture into an online BST algorithm with only a constant factor increase in total search cost. Demaine et al. conjectured this algorithm was dynamically optimal, but no upper bounds were given in their paper. We prove the first nontrivial upper bounds for the cost of search operations using GreedyFuture including giving an access lemma similar to that found in Sleator and Tarjan’s classic paper on splay trees. 1
unknown title
"... of sequence of searches in a splay tree is within a constant factor of the cost of the same sequence of searches in any dynamic binary search tree, even if the competing search algorithm knows the entire sequence in advance. Equivalently, in the language of online algorithms, Sleator and Tarjan conj ..."
Abstract
 Add to MetaCart
of sequence of searches in a splay tree is within a constant factor of the cost of the same sequence of searches in any dynamic binary search tree, even if the competing search algorithm knows the entire sequence in advance. Equivalently, in the language of online algorithms, Sleator and Tarjan conjectured that splay trees are O(1)competitive against an optimal offline adversary. After more than 20 years, this dynamic optimality conjecture remains one of the most frustrating and important open problems in the field of data structures. In fact, it is not known whether any O(1)competitive offline binary search tree exists, nor whether computing the optimal offline strategy for a given access sequence is NPhard. The depth of our ignorance is humbling. One potential way to prove the dynamic optimality conjecture is to develop tighter lower bounds on the cost of the optimal offline search strategy. Three nontrivial lower bounds are currently known: the interleave and alternation bounds proved by Robert Wilber * [5], and the much more recent rectangle cover bound proved by Jonathan Derryberry*, Danny Sleator, and Chengwen Wang * [2]. Conversely, one might approach the problem by developing new dynamic binary search trees that more closely approach the known lower bounds. Essentially only one such structure is known: the tango trees developed by Erik Demaine, Dion Harmon*, John Iacono, and Mihai Pătra¸scu * [1].
6.897: Advanced Data Structures Spring 2003
, 2003
"... In the last lecture we considered the successor problem for a bounded universe of size u. We began looking at the van Emde Boas [3] data structure, which implements Insert, Delete, Successor, and Predecessor in O(lg lg u) time per operation. In this lecture we finish up van Emde Boas, and improve th ..."
Abstract
 Add to MetaCart
In the last lecture we considered the successor problem for a bounded universe of size u. We began looking at the van Emde Boas [3] data structure, which implements Insert, Delete, Successor, and Predecessor in O(lg lg u) time per operation. In this lecture we finish up van Emde Boas, and improve the space complexity from our original O(u) to O(n). We also look at perfect hashing (first static, then dynamic), using it to improve the space complexity of van Emde Boas and to implement a simpler data structure with the same running time, yfast trees. 2 van Emde Boas 2.1 Pseudocode for vEB operations We start with pseudocode for Insert, Delete, and Successor. (Predecessor is symmetric to Successor.) Insert(x, S) if x <min[S]: swap x and min[S] if min[sub[S][high(x)]] = nil: / / was empty Insert(low(x), sub[S][high(x)]) else: min[sub[S][high(x)]] ← low(x) Insert(high(x), summary[S]) if x> max[S]: max[S] ← x Delete(x, S) if min[S] = nil or x < min[S]: return if min[S] = x: i ← min[summary[S]] x ← i � S+ min[sub[S][i]] 1 min[S] ← x Delete(low(x, sub[W][high(x)]) if min[sub[S][high(x)]] = nil: / / now empty Delete(high(x), summary[S]) / / in this case, the first recursive call was cheap Successor(x, S) if x < min[S]: return min[S] if low(x) < max[sub[S][high(x)]] else: return high(x) � S  + Successor(low(x), sub[S][high(x)]) i ← Successor(high(x), summary[S]) return i � S  + min[sub[S][i]] 2.2 Tree view of van Emde Boas The van Emde Boas data structure can be viewed as a tree of trees. The upper and lower “halves ” of the tree are of height 1 2 lg u, that is, we are cutting our tree in halves by level. The upper tree has √ u nodes, as does each of the subtrees hanging off its leaves. (These subtrees correspond to the sub[S] data structures in Section 2.1.)
6.851: Advanced Data Structures Spring 2011
, 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
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 p x x
unknown title
"... For the past few lectures we have been studying self organizing binary search trees. In these two lectures we will study a novel connection between binary search trees(BSTs) and points satisfying a simple property from [1]. Using this correspondence, we will restate many results and conjectures rela ..."
Abstract
 Add to MetaCart
For the past few lectures we have been studying self organizing binary search trees. In these two lectures we will study a novel connection between binary search trees(BSTs) and points satisfying a simple property from [1]. Using this correspondence, we will restate many results and conjectures relating to BSTs and dynamic optimality. 2
Advanced Data Structures JanApr 2012 Lecturer: Venkatesh Raman
, 2012
"... In the last lecture we studied MovetoFront (MTF) Heuristic for a list and its competitive ratio. We also introduced Binary Search Trees (BST) and optimal BSTs. In today’s lecture, we will be analysing Splay Trees and see that they perform as well as an optimal static BST without maintaining extra ..."
Abstract
 Add to MetaCart
In the last lecture we studied MovetoFront (MTF) Heuristic for a list and its competitive ratio. We also introduced Binary Search Trees (BST) and optimal BSTs. In today’s lecture, we will be analysing Splay Trees and see that they perform as well as an optimal static BST without maintaining extra information for balancing the tree. We also discuss the scenario when we have the freedom to begin the search anywhere instead of always starting from the root node. 2 Statically Optimal Search Given a sequence of length m and having n distinct elements. We look at the elements one by one. We want to implement following operations: • insert (i) – If i has not been seen so far in the sequence, insert it in the tree. • access(i) – If i exists in the tree, return a pointer to it. Operation of insert(i) is O(n 2) atmost. We can ignore insertion and w.l.o.g assume we have a tree with all the keys initially and we are performing a sequence of access(i) operations on it. 2.1 Information Entropy and Search Given a set of keys S = [1... n], and frequency of access pi for i ∈ S. The information entropy H is, H = − ∑ piln(pi)