Results 1  10
of
12
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.
Achieving Spatial Adaptivity while Finding Approximate Nearest Neighbors
"... We present the first spatially adaptive data structure that answers approximate nearest neighbor (ANN) queries to points that reside in a geometric space of any constant dimension d. The Ltnorm approximation ratio is O(d 1+1/t), and the running time for a query q is O(d 2 lg δ(p, q)), where p is th ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
We present the first spatially adaptive data structure that answers approximate nearest neighbor (ANN) queries to points that reside in a geometric space of any constant dimension d. The Ltnorm approximation ratio is O(d 1+1/t), and the running time for a query q is O(d 2 lg δ(p, q)), where p is the result of the preceding query and δ(p, q) is the number of input points in a suitablysized box containing p and q. Our data structure has O(dn) size and requires O(d 2 n lg n) preprocessing time, where n is the number of points in the data structure. The size of the bounding box for δ depends on d, and our results rely on the Random Access Machine (RAM) model with word size Θ(lg n). 1
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
(Show Context)
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
A CacheOblivious Implicit Dictionary with the Working Set Property
"... Abstract. In this paper we present an implicit dictionary with the working set property i.e. a dictionary supporting insert(e), delete(x) and predecessor(x) in O(log n) time and search(x) in O(log ℓ) time, where n is the number of elements stored in the dictionary and ℓ is the number of distinct ele ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
Abstract. In this paper we present an implicit dictionary with the working set property i.e. a dictionary supporting insert(e), delete(x) and predecessor(x) in O(log n) time and search(x) in O(log ℓ) time, where n is the number of elements stored in the dictionary and ℓ is the number of distinct elements searched for since the element with key x was last searched for. The dictionary stores the elements in an array of size n using no additional space. In the cacheoblivious model the operations insert(e), delete(x) and predecessor(x) cause O(log B n) cachemisses and search(x) causes O(log B ℓ) cachemisses. 1
Layered workingset trees
 In Proceedings of the 9th Latin American Theoretical Informatics Symposium (LATIN 2010
, 2010
"... The workingset bound [Sleator and Tarjan, J. ACM, 1985] roughly states that searching for an element is fast if the element was accessed recently. Binary search trees, such as splay trees, can achieve this property in the amortized sense, while data structures that are not binary search trees are k ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
The workingset bound [Sleator and Tarjan, J. ACM, 1985] roughly states that searching for an element is fast if the element was accessed recently. Binary search trees, such as splay trees, can achieve this property in the amortized sense, while data structures that are not binary search trees are known to have this property in the worst case. We close this gap and present a binary search tree called a layered workingset tree that guarantees the workingset property in the worst case. The unified bound [Bădoiu et al., TCS, 2007] roughly states that searching for an element is fast if it is near (in terms of rank distance) to a recently accessed element. We show how layered workingset trees can be used to achieve the unified bound to within a small additive term in the amortized sense while maintaining in the worst case an access time that is both logarithmic and within a small multiplicative factor of the workingset bound. 1
Adaptive Binary Search Trees
, 2009
"... A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the wors ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the worst case, various adaptive BST algorithms are capable of exploiting patterns in the sequence of queries to achieve tighter, inputsensitive, bounds that can be o(lg n) in many cases. This thesis furthers our understanding of what is achievable in the BST model along two directions. First, we make progress in improving instancespecific lower bounds in the BST model. In particular, we introduce a framework for generating lower bounds on the cost that any BST algorithm must pay to execute a query sequence,
A Selfadjusting Data Structure for Multidimensional Point Sets ⋆
"... Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known e ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known example of such a data structure is Sleator and Tarjan’s splay tree. In this paper, we introduce a selfadjusting data structure for storing multidimensional point data. The data structure is based on a quadtreelike subdivision of space. Like a quadtree, the data structure implicitly encodes a subdivision of space into cells of constant combinatorial complexity. Each cell is either a quadtree box or the settheoretic difference of two such boxes. Similar to the traditional splay tree, accesses are based on an splaying operation that restructures the tree in order to bring an arbitrary internal node to the root of the tree. We show that many of the properties enjoyed by traditional splay trees can be generalized to this multidimensional version.
CacheOblivious Implicit Predecessor Dictionaries with the WorkingSet Property ∗
"... In this paper we present an implicit dynamic dictionary with the workingset property, supporting insert(e) and delete(e) in O(log n) time, predecessor(e) in O(log ℓ p(e)) time, successor(e) in O(log ℓ s(e)) time and search(e) in O(log min(ℓ p(e), ℓe, ℓ s(e))) time, where n is the number of elements ..."
Abstract
 Add to MetaCart
In this paper we present an implicit dynamic dictionary with the workingset property, supporting insert(e) and delete(e) in O(log n) time, predecessor(e) in O(log ℓ p(e)) time, successor(e) in O(log ℓ s(e)) time and search(e) in O(log min(ℓ p(e), ℓe, ℓ s(e))) time, where n is the number of elements stored in the dictionary, ℓe is the number of distinct elements searched for since element e was last searched for and p(e) and s(e) are the predecessor and successor of e, respectively. The timebounds are all worstcase. The dictionary stores the elements in an array of size n using no additional space. In the cacheoblivious model the log is base B and the cacheobliviousness is due to our black box use of an existing cacheoblivious implicit dictionary. This is the first implicit dictionary supporting predecessor and successor searches in the workingset bound. Previous implicit structures required O(log n) time.
Dynamizing Succinct Tree Representations
"... Abstract. We consider succinct, or spaceefficient, representations of ordinal trees. Representations exist that take 2n + o(n) bits to represent a static nnode ordinal tree – close to the informationtheoretic minimum – and support navigational operations in O(1) time on a RAM model; and some impl ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We consider succinct, or spaceefficient, representations of ordinal trees. Representations exist that take 2n + o(n) bits to represent a static nnode ordinal tree – close to the informationtheoretic minimum – and support navigational operations in O(1) time on a RAM model; and some implementations have good practical performance. The situation is different for dynamic ordinal trees. Although there is theoretical work on succinct dynamic ordinal trees, there is little work on the practical performance of these data structures. Motivated by applications to representing XML documents, in this paper, we report on a preliminary study on dynamic succinct data structures. Our implementation is based on representing the tree structure as a sequence of balanced parentheses, with navigation done using the minmax tree of Sadakane and Navarro (SODA ’10). Our implementation shows promising performance for update and navigation, and our findings highlight two issues that we believe will be important to future implementations: the difference between the finger model of (say) Farzan and Munro (ICALP ’09) and the parenthesis model of Sadakane and Navarro, and the choice of the balanced tree used to represent the minmax tree. 1