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 Davenport-Schinzel sequence S, none of whose subsequences are isomorphic to fixed forbidden subsequence. We direct this technique towards Tarjan’s deque conjecture and prove that n deque operations require O(nα ∗ (n)) time, where α ∗ (n) is the minimum number of applications of the inverse-Ackermann 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.

We present a dynamic comparison-based search structure that supports insertions, deletions, and searches within the unified bound. The unified bound specifies that it is quick to access an element that is near a recently accessed element. More precisely, if w(y) distinct elements have been accessed since the last access to element y, and d(x, y) denotes the rank distance between x and y among the current set of elements, then the amortized cost to access element x is O(miny log[w(y) + d(x, y) + 2]). This property generalizes the working-set and dynamic-finger properties of splay trees. Preprint submitted to Elsevier Science 31 January 2007 1

In this paper we improve, reprove, and simplify a variety of theorems concerning the performance of data structures based on path compression and search trees. We apply a technique very familiar to computational geometers but still foreign to many researchers in (non-geometric) algorithms and data structures, namely, to bound the complexity of an object via its forbidden substructures. To analyze an algorithm or data structure in the forbidden substructure framework one proceeds in three discrete steps. First, one transcribes the behavior of the algorithm as some combinatorial object M; for example, M may be a graph, sequence, permutation, matrix, set system, or tree. (The size of M should ideally be linear in the running time.) Second, one shows that M excludes some forbidden substructure P, and third, one bounds the size of any object avoiding this substructure. The power of this framework derives from the fact that M lies in a more pristine environment and that upper bounds on the size of a P-free object M may be reused in different contexts. All of our proofs begin by transcribing the individual operations of a dynamic data structure

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 working-set bound is a lower bound on the time to access any sequence. Furthermore, we develop a deterministic self-adjusting skip list whose running time matches the working-set bound, thereby achieving dynamic optimality in this class. Finally, we highlight the implications our bounds for skip lists have on multi-way branching search trees such as B-trees, (ab)-trees, and other variants as well as their binary tree representations. In particular, we show a self-adjusting B-tree that is dynamically optimal both in internal and external memory.

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 non-constant 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 multi-splay trees, which can be viewed as a variant of splay trees. We prove the multi-splay 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 multi-splay trees. Specifically, we prove that multi-splay 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 multi-splay trees. Does sequential access take linear time? (Our experiments indicate the answer is “yes”.) Are multi-splay trees dynamically optimal? How do multi-splay 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 multi-splay tree? 1

This thesis introduces the concept of a heterogeneous decomposition of a balanced search tree and apply it to the following problems: • How can finger search be implemented without changing the representation of a Red-Black Tree, such as introducing extra storage to the nodes? (Answer: Any degree-balanced search tree can support finger search without modification in its representation by maintaining an auxiliary data structure of logarithmic size and suitably modifying the search algorithm to make use of this auxiliary data structure.) • Do Multi-Splay Trees, which is known to be O(log log n)-competitive to the optimal binary search trees, have the Dynamic Finger property? (Answer: This is work in progress. We believe the answer is yes.)

views and conclusions contained in this document are those of the author and should not be interpreted as representing the official policies, either expressed or implied, of any sponsoring institution, the U.S. government or any other entity. Keywords: binary search trees, adaptive algorithms, splay trees, Unified Bound, dynamic 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, input-sensitive, 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 instance-specific 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,

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 non-trivial 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