Splaying Preorders and Postorders

TL;DR

This paper proves that splaying preorder and postorder sequences in binary search trees can be done in linear time, leveraging pattern-avoidance and properties of balanced trees, supporting the dynamic optimality conjecture.

Contribution

It introduces new linear-time bounds for splaying preorder and postorder sequences using pattern-avoidance and balanced tree properties.

Findings

Splaying preorder/postorder sequences in an empty BST takes linear time.

Splaying these sequences from a weight-balanced BST also takes linear time.

Preorders and postorders of balanced trees have few large jumps, aiding efficient splaying.

Abstract

Let $T$ be a binary search tree. We prove two results about the behavior of the Splay algorithm (Sleator and Tarjan 1985). Our first result is that inserting keys into an empty binary search tree via splaying in the order of either $T$'s preorder or $T$'s postorder takes linear time. Our proof uses the fact that preorders and postorders are pattern-avoiding: i.e. they contain no subsequences that are order-isomorphic to $(2,3,1)$ and $(3,1,2)$, respectively. Pattern-avoidance implies certain constraints on the manner in which items are inserted. We exploit this structure with a simple potential function that counts inserted nodes lying on access paths to uninserted nodes. Our methods can likely be extended to permutations that avoid more general patterns. Second, if $T'$ is any other binary search tree with the same keys as $T$ and $T$ is weight-balanced (Nievergelt and Reingold 1973), then splaying $T$'s preorder sequence or $T$'s postorder sequence starting from $T'$ takes linear time. To prove this, we demonstrate that preorders and postorders of balanced search trees do not contain many large "jumps" in symmetric order, and exploit this fact by using the dynamic finger theorem (Cole et al. 2000). Both of our results provide further evidence in favor of the elusive "dynamic optimality conjecture."

Equations

$$\mathrm{preorder}(T)$$

$$\mathrm{postorder}(T)$$

$$A_{\alpha }(n)\equiv \max \{{\mathrm{DF}}_T(\mathrm{preorder}(S))\mid \text{S∈BB[α] and ∣T∣=n}\}.$$

$${\mathrm{DF}}_T(\mathrm{preorder}(S))\le {\mathrm{DF}}_T(\mathrm{preorder}(L))+{\mathrm{DF}}_T(\mathrm{preorder}(R))+2{\log }_2(|T|+1).$$

$$A_{\alpha }(n)=\underset{\alpha \le \beta \le 1/2}{\max }\{A_{\alpha }(\beta \cdot n)+A_{\alpha }((1-\beta )\cdot n)\}+O(\log n).$$

Full text

[TABLE]

where $\oplus$ denotes sequence concatenation.444We will refer to any such sequence as a preorder or a postorder. We prove the following results about the behavior of splaying [21] preorders and postorders:

Inserting the nodes of $\operatorname{preorder}(T)$ into an empty tree via splaying costs $O(n)$. (Theorem 2.) 2. 2.

Inserting the nodes of $\operatorname{postorder}(T)$ into an empty tree via splaying costs $O(n)$. (Theorem 3.) 3. 3.

If $T^{\prime}$ has the same keys as $T$ and $T$ is weight-balanced [18] then splaying either $\operatorname{preorder}(T)$ or $\operatorname{postorder}(T)$ starting from $T^{\prime}$ costs $O(n)$. (Theorem 4.)

For 1 and 2, we use the fact that preorders and postorders are pattern-avoiding: i.e. they contain no subsequences that are order-isomorphic to $(2,3,1)$ and $(3,1,2)$, respectively. Pattern-avoidance implies certain constraints on the manner in which items are inserted. We exploit this structure with a simple potential function that counts inserted nodes lying on access paths to uninserted nodes. Our methods can likely be extended to permutations that avoid more general patterns. The proof of 3 uses the fact that preorders and postorders of balanced search trees do not contain many large “jumps” in symmetric order, and exploits this fact using the dynamic finger theorem [6, 5].

Items 2 and 3 are both novel. Item 1 was originally proved by Chaudhuri and Höft [4]; our proof simplifies theirs. These results provide further evidence in favor of the elusive dynamic optimality conjecture [21].

Outline.

Section 1 discusses the mathematical preliminaries, historical background, and context for this investigation, and Section 2 samples some related work. Familiar readers may skip directly to the main results and their proofs, in Sections 3 and 4. Section 3 proves that inserting both preorders and postorders via splaying takes linear time. Section 4 establishes that splaying preorders and postorders of balanced search trees [18] takes linear time, regardless of starting tree. Section 5 provides our thoughts on how to analyze insertion splaying permutations that avoid more general patterns, particularly the class of “$k$-increasing” sequences [3].

1 Preliminaries

Binary Search Trees

A binary tree $T$ contains of a finite set of nodes, with one node designated to be the root. All nodes have a left and a right child pointer, each leading to a different node. Either or both children may be missing, and we denote a missing child by null. Every node in $T$, save for the root, has a single parent node of which it is a child. (The root has no parent.) The size of $T$ is the number of nodes it contains, and is denoted $|T|$.

There is a unique path from $\operatorname{root}(T)$ to every other node $x$ in $T$, called the access path for $x$ in $T$. If $x$ is on the access path for $y$ then we say $x$ is an ancestor of $y$, and $y$ is a descendent of $x$. We refer to the subtree comprising $x$ and all of its descendants as the subtree rooted at $x$. Nodes thus have left and right subtrees rooted respectively at their left and right children. (Subtrees are empty for null children.) The depth of the node $x$, denoted $d_{T}(x)$, is the number of edges on its access path. Its right-depth is the number of right pointers followed, and its left-depth is the number of left pointers followed.

In a binary search tree, every node has a unique key, and the tree satisfies the symmetric order condition: every node’s key is greater than those in its left subtree and smaller than those in its right subtree. The binary search tree derives its name from how its structure enables finding keys. To find a key $k$ initialize the current node to be the root. While the current node is not null and does not contain the given key, replace the current node by its left or right child depending on whether $k$ is smaller or larger than the key in the current node, respectively. The search returns the last current node, which contains $k$ if $k$ is in the tree and otherwise null.

The lowest common ancestor of $x$ and $y$ in $T$, denoted $\operatorname{lca}_{T}(x,y)$, is the deepest node shared by the access paths of both $x$ and $y$. Since the root is a common ancestor of any pair of nodes in $T$ and $T$ is finite, $\operatorname{lca}_{T}(x,y)$ exists and is well defined. Furthermore $\min\{x,y\}\leq\operatorname{lca}_{T}(x,y)\leq\max\{x,y\}$.

To insert a new key $k$ into a binary search tree $T$, we first do a search for $k$ in $T$. When the search reaches a missing node, we replace this node with a node containing the key $k$. (Inserting into an empty tree makes $k$ the root key.)

Rotation

Binary search trees are the canonical data structure for maintaining an ordered set of elements, and are building blocks in countless algorithms. Perhaps the most attractive feature of binary search trees is that the number of comparisons required to find an item in an $n$-node binary search tree is $O(\log n)$, provided that that the tree is properly arranged, which is good in theory and practice. However, without exercising care when inserting nodes, a binary search tree can easily become unbalanced (for example when inserting $1,2,\dots,n$ in order), leading to search costs as high as $\Omega(n)$. Thus, binary search trees require some form of maintenance and restructuring for good performance.

We will employ a restructuring primitive called rotation. A rotation at left child $x$ with parent $y$ makes $y$ the right child of $x$ while preserving symmetric order. A rotation at a right child is symmetric, and rotation at the root is undefined. (See Figure 1). A rotation changes three child pointers in the tree.

Rotations were first employed in “balanced” search trees, which include AVL trees [1], Red-Black trees [10], weight-balanced trees [18], and more recently weak AVL trees [11]. These trees augment nodes with bits that provide rough information about how “balanced” each node’s subtree is. Whenever an item is inserted or deleted, rotations are performed to restore invariants on the balance bits that ensure all search paths have $O(\log n)$ nodes. While balanced searched trees are not the focus of this work, they were progenitors for the main algorithm of interest.

Splay

The Splay algorithm [21] eschews keeping track of balance information, replacing it with an intriguing notion: instead of adjusting the search tree only after insertion and deletion, Splay modifies the tree after every search.

The algorithm begins with a binary search for a key in the tree. Let $x$ be the node returned by this search. If $x$ is not null then the algorithm repeatedly applies a “splay step” until $x$ becomes the root. A splay step applies a certain series of rotations based on the relationship between $x$, its parent, and its grandparent, as follows. If $x$ has no grandparent (i.e. $x$’s parent is the root), then rotate at $x$ (this case is always terminal). Otherwise, if $x$ is a left child and its parent is a right child, or vice-versa, rotate at $x$ twice. Otherwise, rotate at $x$’s parent, and then rotate at $x$. Sleator and Tarjan [21] assigned the respective names zig, zig-zag and zig-zig to these three cases. The series of splay steps that bring $x$ to the root are collectively called to as splaying at $x$, or simply splaying $x$. The three cases are depicted in Figure 2.

The cost of splaying a single item $x$ in $T$ is defined to be $d_{T}(x)+1$.555We absorb the search cost into the rotations. If $X=(x_{1},\dots,x_{m})$ is a sequence of requested keys in $T$ then the cost of splaying $X$ starting from $T$ is defined as $m+\sum_{i=1}^{m}d_{T_{i-1}}(x_{i})$, where $T_{0}=T$, and for $1\leq i\leq m$, we form $T_{i}$ by splaying $x_{i}$ in $T_{i-1}$. To perform insertion splaying, insert a key into the tree and then splay the newly created node. The cost of an insertion splay is the cost splaying the new node.

While splaying individual items can cost $\Omega(n)$, the total cost of splaying $m$ requested items in a tree of size $n>0$ is $O((m+n)\log n)$. Hence, the worst case cost of a splay operation, amortized over all the requests, is the same as any balanced binary search tree. This is perhaps surprising for an algorithm that keeps no record of balance information.

What makes Splay truly remarkable is how it takes advantage of “latent structure” in the request sequence, and provides more than simple “worst-case” guarantees. As just one example, if $t_{X}(i)$ is the number of different items accessed before access $i$ since the last access to item $x_{i}$ (or since the beginning of the sequence if $i$ is the first access to $x_{i}$), then the cost to splay $X$ starting from $T$ is $O(n\log n+\sum_{j=1}^{m}\log(t_{X}(j)+1))$ [21].666Note that $O(\log n)$ amortized cost per splay is a corollary of this. (This is called the “working set” property.) Thus, Splay exploits “temporal locality” in the access pattern.

Splay simultaneously exploits “spatial” locality, as shown by the following theorem (originally conjectured in [21]) that we will use later on:

Theorem 1** (Dynamic Finger [6, 5]).**

Let the rank of $x$ in $T$, denoted $r_{T}(x)$, be the number of nodes in $T$ whose keys are less than or equal the key in $x$. The cost of splaying $X=(x_{1},\dots,x_{m})$ starting from $T$ is $O(|T|+m+\operatorname{DF}_{T}(X))$, where $\operatorname{DF}_{T}(X)\equiv\sum_{i=2}^{m}\log_{2}(|r_{T}(x_{i})-r_{T}(x_{i-1})|+1)$.

In fact, the properties of Splay inspired the authors of [21] to speculate on a much stronger possibility: that Splay’s cost is always within a constant factor of the “optimal” way of executing the requests. Formally, an execution $E$ for $(X,T)$ comprises the following. Let $T_{0}=T$, and for $1\leq i\leq m$, we perform some number $e_{i}\geq 0$ of rotations starting from $T_{i-1}$ to form $T_{i}$, followed by a search for $x_{i}$. The cost of this execution is $\sum_{i=1}^{m}(1+e_{i}+d_{T_{i-1}}(x_{i}))$. The optimal cost \operatorname{OPT}(X,T)\equiv\min\{\operatorname{cost}(E)\mid\text{E$executes$(X,T)}\}. The following conjecture has spawned a great deal of related research (see §2):

Conjecture 1** (Dynamic Optimality [21]).**

$\operatorname{cost}_{\text{splay}}(X,T)=O(\operatorname{OPT}(X,T))$.

The conjecture remains open. In fact, there is no sub-exponential time algorithm whatsoever that is known to compute, even to within a constant factor, the cost of an optimum binary search tree execution for an instance. There are several known lower bounds [7, 25], none known to be tight (though some conjectured to be).

Pattern-Avoidance

For simplicity, we restrict subsequent discussion to permutation request sequences (i.e. no key is requested twice). By [3], any algorithm that achieves optimal cost on all permutations can be extended to an algorithm that is optimal for all request sequences.

An auxiliary question to determining if Splay (or any other algorithm) is dynamically optimal is: “what class(es) of permutations have optimum executions with ‘low’ cost?” This issue is not a mere curiosity, as almost every permutation of length $n$ has optimal execution cost $\Theta(n\log n)$ [14], a bound achieved by any balanced search tree. Thus, in the absence of insertions or deletions, adjusting the tree after every access only gives an advantage on a small subset of “structured” request sequences. In addition, these structured request sequences provide candidate counter-examples to dynamic optimality. In this work, we focus on certain pattern-avoiding permutations: those that do not contain any subsequences of a specified type. More formally:777The following definitions and theorems are taken from [13, Chapter 1.3], almost verbatim.

Two permutations $\alpha=(a_{1},\dots,a_{n})$ and $\beta=(b_{1},\dots,b_{n})$ of the same length are order-isomorphic if their entries have the same relative order, i.e. $a_{i}<a_{j}\iff b_{i}<b_{j}$. For example, $(5,8,1)$ is order-isomorphic to $(2,3,1)$. A sequence $\pi$ avoids a sequence $\alpha$ (or is called $\alpha$-avoiding) if it has no subsequence that is order-isomorphic with $\alpha$. If $\pi$ is $\alpha$-avoiding then all subsequences of $\pi$ are $\alpha$-avoiding. We use $\pi\setminus\alpha$ as shorthand for “an (arbitrary) permutation $\pi$ that avoids $\alpha$.” Both preorders and postorders may be characterized as pattern-avoiding permutations:

Lemma 1** (Lemma 1.4 from [13]).**

For any permutation $\pi$:

1. (a)

$\pi=\operatorname{preorder}(T)$* for some binary search tree $T$ $\iff\pi$ avoids $(2,3,1)$.* 2. (b)

$\pi=\operatorname{postorder}(T)$* for some binary search tree $T$ $\iff\pi$ avoids $(3,1,2)$.*

Sketch.

For preorders, Kozma builds a bijection between binary search trees and $(2,3,1)$-avoiding sequences, and uses a simple argument by contradiction to show preorders avoid $(2,3,1)$ [13]. The proof for postorders is a nearly symmetric variation of this argument. ∎

2 Related Work

The first result about Splay’s behavior on pattern-avoiding request sequences was the sequential access theorem [24]: the cost of splaying the nodes of $T$ in order is $O(|T|)$. This is a special case of a corollary888A priori, the traversal conjecture follows from dynamic optimality conditioned on Splay being optimal with low “additive overhead.” The authors recently proved that this corollary is actually unconditional [15]. of dynamic optimality:

Conjecture 2** (Traversal [21]).**

There exists $c>0$ for which the cost of splaying $\operatorname{preorder}(T)$ starting from $T^{\prime}$ is at most $c|T|$ for all pairs of binary search trees $T,T^{\prime}$ with the same keys.

Theorem 2 and [4] is another special case, when $T=T^{\prime}$. In §3 we prove a new special case: when $T$ is $\alpha$-weight balanced.

Interest in the behavior of binary search tree algorithms on “structured” request sequences was revived by Seth Pettie’s analysis of the performance of Splay-based deque data structures using Davenport-Schinzel sequences [20], and his later reproof of the sequential access theorem via the theory of forbidden submatrices [19].

This analysis was later adapted to and greatly extended for another binary search tree algorithm, colloquially known as “Greedy,” that was first proposed as an off-line algorithm independently by Lucas [16] and Munro [17]. Greedy is widely conjectured to be dynamically optimal, and is known to have many of the same properties of Splay, including the working set [8] and dynamic finger [12] bounds.

Greedy was later recast as an on-line algorithm in a “geometric” view of binary search trees [7]. This geometric view of Greedy is especially amenable to forbidden submatrix analysis. In [3], Chalermsook et. al. show that Greedy has nearly-optimal run-time on a broad class of pattern-avoiding permutations. Moreover, they demonstrate that if Greedy is optimal on a certain class of “non-decomposable” permutations then it is dynamically optimal. Chalermsook et al.’s analysis was later simplified in [9].

3 Insertion Splaying Preorders and Postorders

If $\pi=(p_{1},\dots,p_{n})$ is a permutation then the insertion tree for $\pi$, denoted $\operatorname{BST}(\pi)$, is the binary search tree obtained by starting from an empty tree and inserting keys in order of their first appearance in $\pi$.

Lemma 2**.**

If $x$ is a proper ancestor of $y$ in $\operatorname{BST}(\pi)$ then $x$ precedes $y$ in $\pi$.

Proof.

Let $\pi_{\prec y}$ denote the prefix of $\pi$ containing the elements preceding $y$. By construction, $y$ is inserted as a child of some node $z$ in $\operatorname{BST}(\pi_{\prec y})$. Every proper ancestor of $y$ is an ancestor of $z$, thus $x\in\operatorname{BST}(\pi_{\prec y})$. Hence, $x$ precedes $y$. ∎

Insertion splaying $\pi$ has the same cost as splaying $\pi$ starting from $\operatorname{BST}(\pi)$.999This is because the manner in which Splay restructures the access path is independent of nodes outside the path. For the purposes of analysis we will assume that, initially, every node in $\operatorname{BST}(\pi)$ is marked as untouched. An insertion splay marks the node as touched, and then splays the node. The touched nodes form a connected subtree containing the root, called the touched subtree. The untouched nodes form subtrees each of which contains no touched node. Call an untouched node with a touched parent a sub-root. The subtrees rooted at sub-roots have identical structure in both the splayed tree and $\operatorname{BST}(\pi)$. By Lemma 2, the next node to be touched is always a sub-root.

For $1\leq i\leq n$, form $T_{i}$ by touching and then splaying $p_{i}$ in $T_{i-1}$, where $T_{0}=\operatorname{BST}(\pi)$ starts with all nodes untouched. At any time we define the potential to be the twice the number of touched nodes that are ancestors of sub-roots, and we define $\Phi_{i}$ to be the potential of $T_{i}$. The amortized cost of splaying $p_{i}$ in $T_{i-1}$ is defined as $c_{i}=t_{i}+\Phi_{i}-\Phi_{i-1}$, where $t_{i}$ denotes the actual cost. By a standard telescoping sum argument, the cost of insertion splaying $\pi$ is $\sum_{i=1}^{n}t_{i}=\sum_{i=1}^{n}c_{i}+\Phi_{0}-\Phi_{n}$ [23]. Since $\Phi_{0}=\Phi_{n}=0$, an upper bound on amortized cost provides an upper bound on the actual cost.

Pattern-avoidance provides certain information about both $\operatorname{BST}(\pi)$ and about which sub-root can be touched next. We exploit this information in the next two sections.

Preorders

There are no restrictions on the possible structure of preorder insertion trees as $\operatorname{BST}(\operatorname{preorder}(T))=T$.101010In fact, this property is shared by any permutation $\pi$ for which every node in $T$ appears in $\pi$ before those in its left and right subtrees. However, the manner in which sub-roots are chosen is particularly simple.

Lemma 3**.**

If $\pi\setminus(2,3,1)=(p_{1},\dots,p_{n})$ is a preorder then, for $1\leq i\leq n$, $p_{i}$ is the smallest sub-root of $T_{i-1}$, where all nodes begin untouched in $T_{0}=\operatorname{BST}(\pi)$ and $T_{i}$ is formed by touching and splaying $p_{i}$ in $T_{i-1}$.

Proof.

The statement is vacuously true for $i=1$. We prove for $i>1$ by contradiction, as follows. Suppose $T_{i-1}$ has some sub-root $q$ that is smaller than $p_{i}$. Since $q$ and $p_{i}$ are both sub-roots in $T_{i-1}$, they are both children of respective (though not necessarily distinct) nodes $a$ and $b$ in $T_{i-1}$. Let $r=\operatorname{lca}_{T_{i-1}}(a,b)$. Since $q\neq a$ and $p_{i}\neq b$, all of $p_{i}$, $q$ and $r$ are distinct nodes in $T_{i-1}$, and furthermore $q<r<p_{i}$. By Lemma 2, $r$ precedes both $q$ and $p_{i}$ in $\pi$, and by construction $p_{i}$ precedes $q$. We thus have $(r,p_{i},q)$ is a subsequence of $\pi$. But $(r,p_{i},q)$ is order-isomorphic with $(2,3,1)$, contradicting $\pi\setminus(2,3,1)$. ∎

Theorem 2**.**

Insertion splaying $\operatorname{preorder}(T)$ keeps each sub-root at left-depth at most $1$ and takes $O(1)$ amortized time per splay operation.

Proof.

The theorem is trivial for the first insertion splay. The inductive hypothesis is that every sub-root has left depth [math] or $1$. Let $x$ be the next sub-root to be splayed, and let $y$ and $z$ (either or both of which can be missing) be its left and right children. Touching $x$ makes $y$ and $z$ into sub-roots.

Suppose $x$ has left depth [math] before it is touched. Converting $x$ from untouched to touched (without splaying it) increases the potential by at most $2$ and gives the new sub-roots $y$ and $z$ left depths of $1$ and [math], respectively. (In this case they are the only two sub-roots.) Each splay step, except possibly the last, is a zig-zig in which $x$ starts as a left child with parent $p$ and grandparent $g$. After completing the zig-zig, $g$ is no longer an ancestor of any untouched node, which decreases the potential by $2$. The zig-zig also preserves the left depths of $y$ and $z$. ($y$ becomes the right child of $p$.) No other sub-roots can increase left-depth, as $x$ is the smallest sub-root. If the last splay step is a zig, the potential does not change (although the length of the path to $y$ increases by $1$).

More complicated is the case in which $x$ has left depth $1$. Converting $x$ from untouched to touched (without splaying it) makes $y$ a sub-root of left depth $2$ and $z$ a sub-root of left depth $1$. Let $w$ be the parent of the ancestor of $x$ that is a left child. All other sub-roots are in the right subtree of $w$, which is unaffected by splaying $x$. The splay of $x$ consists of [math] or more left zig-zigs, followed by a zig-zag (which can either left-right or right-left), followed by zero of more left zig-zigs, followed possibly by a zig. Each zig-zig reduces the potential by $2$ and preserves the left depths of all sub-roots. The zig-zag does not increase the potential, reduces the left depth of $y$ from $2$ to $1$, and that of $x$ from $1$ to [math], and preserves the left depth of $z$. Now $x$ has left depth [math], and the argument above applies to the remaining splay steps.

By Lemma 3, the next node to be splayed will be $y$ if present, otherwise $z$ if present, otherwise $w$ if present. All three of these items have left-depth [math] or $1$, hence an identical form to Figure 3. Thus the hypothesis holds.

To obtain the constant factor, we observe that converting $x$ from untouched to touched increases the potential by $2$. Each zig-zig step pays for itself: it requires $2$ rotations, paid for by the potential decreasing by at least $2$. The zig-zag requires $2$ rotations, and the zig requires $1$ rotation. If the cost of a splay is the number of nodes on the splay path, equal to the number of rotations plus $1$, we have an amortized cost of $6$ per splay. ∎

Postorders

Postorder insertion trees are more restricted. A binary search tree $C$ is a (left-toothed) comb if the access path for $x\in C$ always comprises some number $j\geq 0$ of right children followed by some number $k\geq 0$ of left children. The nodes of $C$ are partitioned into teeth, where every node in the $i\textsuperscript{th}$ tooth has right-depth $i-1$. The shallowest node in a tooth is called the head. The insertion trees of postorders are combs:

Lemma 4**.**

If $\pi$ is a postorder then no left child in $\operatorname{BST}(\pi)$ has a right child.

Proof.

By contradiction. Let $y$ be a left child in $\operatorname{BST}(\pi)$ with right child $z$, and let $x=\operatorname{parent}(y)$. As $z$ is $y$’s right child, $y<z$. Similarly, as both $y$ and $z$ are in $x$’s left subtree, $y<z<x$. By Lemma 2, $y$ can be an ancestor of $z$ only if $y$ precedes $z$ in $\pi$, and similarly $x$ must precede $y$. Thus, $(x,y,z)$ is a subsequence of $\pi$ that is order-isomorphic to $(3,1,2)$. By Lemma 1(b), $\pi$ is not a postorder. ∎

While postorder insertion trees are less varied than for preorders, there may be many postorders with a given insertion tree. This affords some amount of freedom for choosing different sub-roots.

Lemma 5**.**

Let $\pi\setminus(3,1,2)=(p_{1},\dots,p_{n})$ be a postorder with insertion tree sequence $T_{0},T_{1},\dots,T_{n}$. For $1\leq i\leq n$, $p_{i}$ is either:

1. (a)

The single sub-root greater than $\max\{T_{i-1}\}$ (if present), or 2. (b)

The largest sub-root smaller than $\max\{T_{i-1}\}$ (if present).

Proof.

The result is vacuous for $i=1,2$. If $p_{i}$ is case (a), we merely note that if $p_{i}$ is a new maximum then it must be the right child of the largest node in $\max\{T_{i-1}\}$. There can be at most one sub-root in this position. Hence, $p_{i}$ is unique.

For the sake of contradiction, suppose $p_{i}$ is not of the form in case (a) or (b), and let $q$ be the largest sub-root smaller than $\max\{T_{i-1}\}$. By Lemma 2, the items of each tooth are added in decreasing order. As $q$ is not the head of its tooth, its successor $r$ must be in $T_{i-1}$, and furthermore $r$ precedes both $p_{i}$ and $q$ in $\pi$. By construction, $(r,p_{i},q)$ is a subsequence of $\pi$. Yet this subsequence is isomorphic to $(3,1,2)$ since $p_{i}<q<r$, contradicting Lemma 1(b). ∎

Theorem 3**.**

Insertion splaying postorders maintains the following invariants:

After each insertion splay, the path to every sub-root comprises $j\geq 0$ left pointers followed by $k\geq 0$ right pointers. (Furthermore, after the first insertion, $k\geq 1$.) 2. 2.

The left-depth of every sub-root decreases from smallest to largest.111111The first two invariants dictate that the ancestors of sub-roots form a right-toothed comb. 3. 3.

The splay operation takes constant amortized time.

Proof.

The base case is trivial. Lemma 5 dictates that the next splayed sub-root is either greater than all marked items, or is the largest sub-root smaller than the tree root. Let $x$ be the next node to be insertion splayed, $y$ its left child, and $z$ its right child (either or both children may be missing).

Suppose $x$ is greater than the current tree root. Marking $x$ increases the potential by $2$ and makes $y$ and $z$ new sub-roots. The splay operation brings $x$ to the root by a sequence of left zig-zigs followed possibly by a left zig (depending on whether the length of the access path is odd or even). After each one of these zigs or zig-zigs, $y$’s left-depth remains $1$, and $z$’s left depth remains [math]. Let $v$ be the root prior to the splay operation. If the last splay step is a zig then the last splay operation increases the left depth of $v$ and everything in its left subtree by either $1$ or $2$. Since the left-depth of $x$ was [math] and $x$ was the largest sub-root, the inductive hypothesis ensures that all sub-roots had left-depth at least $1$ before the splay operation, and therefore at least $2$ afterward. Thus, when $x$ becomes the root, the left-depths of each sub-root decrease from left to right.

Otherwise, $x$ is the largest sub-root less than the root. Marking $x$ again increases the potential by at most $2$. By Lemma 4, $x$ has no right child (see Figure 4), so we only need to worry about its left child $y$. Let $w$ be the last ancestor of $x$ that is a left child. Each left zig-zig prior to the splay step involving $w$ maintains the left-depth of $y$ to be one greater than the left-depth of $x$. The splay step involving $w$ will either be a left zig-zig or a left-right zig-zag, depending on the length of the original path connecting $w$ to $x$. Regardless, immediately after the splay step involving $w$, the ancestor of $y$ that is the left child of $x$ is either the left child of $w$ or the left child of $w$’s parent. Since all the sub-roots less than $y$ are in the left subtree of $w$, and thus have left-depth greater than the left-depth of $y$, the invariant is restored, and remains true after each right zig-zig or zig that brings $x$ to the root.

All that remains is showing constant amortized time. As noted before, marking $x$ costs $2$. If $x$ is greater than the root then each left zig-zig, except possibly the last, pays for itself, giving amortized cost of $4$. In the other case, all splay steps except for the one involving $w$ and the one making $x$ the root pay for themselves, giving amortized cost at most $6$. ∎

4 Balanced Trees

Let $|x|$ denote the size of the subtree rooted at $x$. Following [18], we say $T$ is $\alpha$ weight balanced for $\alpha\in(0,1/2]$ if $\min\{|\operatorname{left}(x)|,|\operatorname{right}(x)|\}+1\geq\alpha\cdot(|x|+1)$ for all $x\in T$, and write $T\in\operatorname{BB}[\alpha]$.

Theorem 4**.**

For any (fixed) $0<\alpha\leq 1/2$, if $S\in\operatorname{BB}[\alpha]$ and $T$ has the same keys as $S$, then the cost of splaying $\operatorname{preorder}(S)$ or $\operatorname{postorder}(S)$ starting from $T$ is $O(|T|)$.

Proof.

By Theorem 1, it suffices to show that $\operatorname{DF}_{T}(\operatorname{preorder}(S))=O(|T|)$. Let

[TABLE]

Recall that $\operatorname{preorder}(S)=(\operatorname{root}(S))\oplus\operatorname{preorder}(L)\oplus\operatorname{preorder}(R)$, where $L$ and $R$ are the left and right subtrees of the root of $S$, respectively. Notice that the rank differences between $\operatorname{root}(S)$ and the first item in $\operatorname{preorder}(L)$, and between the last item in $\operatorname{preorder}(L)$ and the first item in $\operatorname{preorder}(R)$, are at most $|T|$ by definition. Hence,

[TABLE]

Observe that $(|L|+1)/(|S|+1)\in[\alpha,1-\alpha]$ since $S\in\operatorname{BB}[\alpha]$, and by definition $|R|<|S|-|L|$. Hence,

[TABLE]

Akra-Bazzi’s result [2] suffices to show $A_{\alpha}(n)=O(n)$ for fixed $\alpha$. The proof for postorders is identical. ∎

Remark 1**.**

In actuality, $A_{\alpha}(n)=O(f(\alpha)\cdot n)$ for some function $f$ of $\alpha$. Unfortunately, the computation appears to be messy. We have declined to do the necessary footwork, as we strongly suspect that, regardless, $A_{\alpha}(n)$ does not tightly bound the cost of splaying these sequences.

Remark 2**.**

This result extends to any binary search tree algorithm that satisfies the dynamic finger bound. Iacono and Langerman proved Greedy also has the dynamic finger property [12]; their analysis does not consider initial trees, however.

5 Remarks

Patterns that avoid $(2,1,3)$ are “symmetric” to those that avoid $(2,3,1)$: if $\pi\setminus(2,1,3)$ then $\pi$ is the preorder of the mirror image of $\operatorname{BST}(\pi)$. Similarly, patterns that avoid $(1,3,2)$ are symmetric to patterns that avoid $(3,1,2)$. Thus, insertion splaying $\pi\setminus(2,1,3)$ and $\pi\setminus(1,3,2)$ takes linear time.

The only other patterns of length three are $(3,2,1)$ and its symmetric counterpart $(1,2,3)$. The pattern $(3,2,1)$ was explored in [3], where it was shown that Greedy executes $(3,2,1)$-avoiding permutations in linear time starting from an arbitrary tree. In fact, they showed that executing $\pi\setminus(k,\dots,2,1)$ takes time proportional to $n\cdot 2^{O(k^{2})}$; this is linear in $n$ for fixed $k$. These permutations are called $k$-increasing because they can be partitioned into $k-1$ disjoint monotonically increasing subsequences [3]. They form the natural generalization of sequential access, which is the (unique) permutation of the tree nodes that avoids $(2,1)$.

More general invariants can be derived about insertion tree structure and sub-root insertion order based on pattern-avoidance. As one particularly interesting example:

Theorem 5**.**

If $\pi\setminus(k,\dots,2,1)$ then no node in $\operatorname{BST}(\pi)$ has left-depth more than $k-2$, and the next sub-root inserted (without splaying) is always the smallest sub-root with its given left-depth.

The proof is similar to Lemmas 4 and 5. In particular, the insertion trees of $(3,2,1)$-avoiding permutations look like the combs of postorder insertion trees, except the teeth are rightward, instead of leftward paths.

For $k$-increasing sequences, the potential used for Theorems 2 and 3 needs modifications. The main issue is that in both of these cases, the zig-zigs paid for themselves because the nodes knocked off the access path did not have sub-root descendants. This structure no longer holds for $(3,2,1)$-avoiding sequences, since we must splay the nodes of the teeth in increasing order. The proof seems to require a generalization of the sequential access theorem. It is possible that the notion of kernel trees used by Sundar in [22] for a potential-based proof of the sequential access theorem could be useful.