Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

Everything was balanced before the computers went off line. Try and adjust something,and you unbalance something else. Try and adjust that, you unbalance two more andbefore you know what’s happened, the ship is out of control.
— Blake, Blake’s 7, “Breakdown” (March 6, 1978)
A good scapegoat is nearly as welcome as a solution to the problem.
— Anonymous
Let’s play.
— El Mariachi [Antonio Banderas], Desperado (1992)

CAPTAIN: TAKE OFF EVERY ’ZIG’!!
CAPTAIN: YOU KNOW WHAT YOU DOING.
CAPTAIN: MOVE ’ZIG’.
CAPTAIN: FOR GREAT JUSTICE.
— Zero Wing (1992)

ÆÆÆ

10

Scapegoat and Splay Trees

10.1

Definitions
Move intro paragraphs to earlier treap notes, or maybe to new appendix on basic data
structures (arrays, stacks, queues, heaps, binary search trees).

I’ll assume that everyone is already familiar with the standard terminology for binary searchtrees—node, search key, edge, root, internal node, leaf, right child, left child, parent, descendant,
sibling, ancestor, subtree, preorder, postorder, inorder, etc.—as well as the standard algorithms
for searching for a node, inserting a node, or deleting a node. Otherwise, consult your favorite
data structures textbook.
For this lecture, we will consider only full binary trees—where every internal node has exactly
two children—where only the internal nodes actually store search keys. In practice, we canrepresent the leaves with null pointers.
Recall that the depth of a node is its distance from the root, and its height is the distance tothe farthest leaf in its subtree. The height (or depth) of the tree is just the height of the root.
The size of a node is the number of nodes in its subtree. The size n of the whole tree is just the
total number of nodes.
A tree with height h has at most 2h leaves, so the minimum height of an n-leaf binary tree
is dlg ne. In the worst case, the time required for a search, insertion, or deletion to the heightof the tree, so in general we would like keep the height as close to lg n as possible. The best
we can possibly do is to have a perfectly balanced tree, in which each subtree has as close tohalf the leaves as possible, and both subtrees are perfectly balanced. The height of a perfectly
balanced tree is dlg ne, so the worst-case search time is O(log n). However, even if we started
with a perfectly balanced tree, a malicious sequence of insertions and/or deletions could makethe tree arbitrarily unbalanced, driving the search time up to Θ(n).
To avoid this problem, we need to periodically modify the tree to maintain ‘balance’. There
are several methods for doing this, and depending on the method we use, the search tree isgiven a different name. Examples include AVL trees, red-black trees, height-balanced trees,
weight-balanced trees, bounded-balance trees, path-balanced trees, B-trees, treaps, randomized© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms/ for the most recent revision.

1

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

binary search trees, skip lists,1 and jumplists. Some of these trees support searches, insertions,and deletions, in O(log n) worst-case time, others in O(log n) amortized time, still others inO(log n) expected time.
In this lecture, I’ll discuss three binary search tree data structures with good amortized
performance. The first two are variants of lazy balanced trees: lazy weight-balanced trees,developed by Mark Overmars* in the early 1980s, [14] and scapegoat trees, discovered by Arne
Andersson* in 1989 [1, 2] and independently2 by Igal Galperin* and Ron Rivest in 1993 [11]. The
third structure is the splay tree, discovered by Danny Sleator and Bob Tarjan in 1981 [19, 16].

10.2

Lazy Deletions: Global Rebuilding

First let’s consider the simple case where we start with a perfectly-balanced tree, and we only
want to perform searches and deletions. To get good search and delete times, we can use atechnique called global rebuilding. When we get a delete request, we locate and mark the node
to be deleted, but we don’t actually delete it. This requires a simple modification to our searchalgorithm—we still use marked nodes to guide searches, but if we search for a marked node, thesearch routine says it isn’t there. This keeps the tree more or less balanced, but now the searchtime is no longer a function of the amount of data currently stored in the tree. To remedy this,we also keep track of how many nodes have been marked, and then apply the following rule:
Global Rebuilding Rule. As soon as half the nodes in the tree have been marked,
rebuild a new perfectly balanced tree containing only the unmarked nodes.3
With this rule in place, a search takes O(log n) time in the worst case, where n is the number ofunmarked nodes. Specifically, since the tree has at most n marked nodes, or 2n nodes altogether,
we need to examine at most lg n + 1 keys. There are several methods for rebuilding the tree inO(n) time, where n is the size of the new tree. (Homework!) So a single deletion can cost Θ(n)time in the worst case, but only if we have to rebuild; most deletions take only O(log n) time.
We spend O(n) time rebuilding, but only after Ω(n) deletions, so the amortized cost of
rebuilding the tree is O(1) per deletion. (Here I’m using a simple version of the ‘taxation method’.
For each deletion, we charge a $1 tax; after n deletions, we’ve collected $n, which is just enoughto pay for rebalancing the tree containing the remaining n nodes.) Since we also have to findand mark the node being ‘deleted’, the total amortized time for a deletion is O(log n).

10.3

Insertions: Partial Rebuilding

Now suppose we only want to support searches and insertions. We can’t ‘not really insert’ newnodes into the tree, since that would make them unavailable to the search algorithm.⁴ So
instead, we’ll use another method called partial rebuilding. We will insert new nodes normally,
but whenever a subtree becomes unbalanced enough, we rebuild it. The definition of ‘unbalanced
enough’ depends on an arbitrary constant α > 1.
Each node v will now also store height(v) and size(v). We now modify our insertion algorithmwith the following rule:
1Yeah, yeah. Skip lists aren’t really binary search trees. Whatever you say, Mr. Picky.
2The claim of independence is Andersson’s [2]. The two papers actually describe very slightly different rebalancing
algorithms. The algorithm I’m using here is closer to Andersson’s, but my analysis is closer to Galperin and Rivest’s.
3Alternately: When the number of unmarked nodes is one less than an exact power of two, rebuild the tree. This
rule ensures that the tree is always exactly balanced.
⁴Well, we could use the Bentley-Saxe* logarithmic method [3], but that would raise the query time to O(log2 n).

2Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

Partial Rebuilding Rule. After we insert a node, walk back up the tree updating
the heights and sizes of the nodes on the search path. If we encounter a node v
where height(v) > α · lg(size(v)), rebuild its subtree into a perfectly balanced tree
(in O(size(v)) time).
If we always follow this rule, then after an insertion, the height of the tree is at most α · lg n.
Thus, since α is a constant, the worst-case search time is O(log n). In the worst case, insertions
require Θ(n) time—we might have to rebuild the entire tree. However, the amortized time foreach insertion is again only O(log n). Not surprisingly, the proof is a little bit more complicatedthan for deletions.
Define the imbalance I(v) of a node v to be the absolute difference between the sizes of its
two subtrees:
Imbal(v) := |size(left(v)) − size(right(v))|
A simple induction proof implies that Imbal(v) ≤ 1 for every node v in a perfectly balanced tree.
In particular, immediately after we rebuild the subtree of v, we have Imbal(v) ≤ 1. On the other
hand, each insertion into the subtree of v increments either size(left(v)) or size(right(v)), so
Imbal(v) changes by at most 1.
The whole analysis boils down to the following lemma.
Lemma 1. Just before we rebuild v’s subtree, Imbal(v) = Ω(size(v)).
Before we prove this lemma, let’s first look at what it implies. If Imbal(v) = Ω(size(v)), thenΩ(size(v)) keys have been inserted in the v’s subtree since the last time it was rebuilt from scratch.
On the other hand, rebuilding the subtree requires O(size(v)) time. Thus, if we amortize therebuilding cost across all the insertions since the previous rebuild, v is charged constant time foreach insertion into its subtree. Since each new key is inserted into at most α · lg n = O(log n)subtrees, the total amortized cost of an insertion is O(log n).
Proof: Since we’re about to rebuild the subtree at v, we must have height(v) > α · lg size(v).
Without loss of generality, suppose that the node we just inserted went into v’s left subtree. Either
we just rebuilt this subtree or we didn’t have to, so we also have height(left(v)) ≤ α·lg size(left(v)).
Combining these two inequalities with the recursive definition of height, we get
α · lg size(v) < height(v) ≤ height(left(v)) + 1 ≤ α · lg size(left(v)) + 1.
After some algebra, this simplifies to size(left(v)) > size(v)/21/α . Combining this with the identitysize(v) = size(left(v)) + size(right(v)) + 1 and doing some more algebra gives us the inequality
size(right(v)) < 1 − 1/21/α size(v) − 1.
Finally, we combine these two inequalities using the recursive definition of imbalance.
Imbal(v) ≥ size(left(v)) − size(right(v)) − 1 > 2/21/α − 1 size(v)Since α is a constant bigger than 1, the factor in parentheses is a positive constant.

3

Algorithms

10.4

Lecture 10: Scapegoat and Splay Trees [Fa’13]

Scapegoat (Lazy Height-Balanced) Trees

Finally, to handle both insertions and deletions efficiently, scapegoat trees use both of the previous
techniques. We use partial rebuilding to re-balance the tree after insertions, and global rebuilding
to re-balance the tree after deletions. Each search takes O(log n) time in the worst case, and theamortized time for any insertion or deletion is also O(log n). There are a few small technicaldetails left (which I won’t describe), but no new ideas are required.
Once we’ve done the analysis, we can actually simplify the data structure. It’s not hard toprove that at most one subtree (the scapegoat) is rebuilt during any insertion. Less obviously, we
can even get the same amortized time bounds (except for a small constant factor) if we only
maintain the three integers in addition to the actual tree: the size of the entire tree, the heightof the entire tree, and the number of marked nodes. Whenever an insertion causes the tree tobecome unbalanced, we can compute the sizes of all the subtrees on the search path, starting at
the new leaf and stopping at the scapegoat, in time proportional to the size of the scapegoat
subtree. Since we need that much time to re-balance the scapegoat subtree, this computation
increases the running time by only a small constant factor! Thus, unlike almost every other kindof balanced trees, scapegoat trees require only O(1) extra space.

10.5

Rotations, Double Rotations, and Splaying

Another method for maintaining balance in binary search trees is by adjusting the shape of thetree locally, using an operation called a rotation. A rotation at a node x decreases its depth by
one and increases its parent’s depth by one. Rotations can be performed in constant time, since
they only involve simple pointer manipulation.
y

right

x

x
y

left

Figure 1. A right rotation at x and a left rotation at y are inverses.

For technical reasons, we will need to use rotations two at a time. There are two types ofdouble rotations, which might be called zig-zag and roller-coaster. A zig-zag at x consists of tworotations at x, in opposite directions. A roller-coaster at a node x consists of a rotation at x’s
parent followed by a rotation at x, both in the same direction. Each double rotation decreases
the depth of x by two, leaves the depth of its parent unchanged, and increases the depth ofits grandparent by either one or two, depending on the type of double rotation. Either type of
double rotation can be performed in constant time.
Finally, a splay operation moves an arbitrary node in the tree up to the root through a seriesof double rotations, possibly with one single rotation at the end. Splaying a node v requires time
proportional to depth(v). (Obviously, this means the depth before splaying, since after splaying v
is the root and thus has depth zero!)

10.6

Splay Trees

A splay tree is a binary search tree that is kept more or less balanced by splaying. Intuitively, after
we access any node, we move it to the root with a splay operation. In more detail:4

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

z

z

w

x

x

w

w

x

z

Figure 2. A zig-zag at x . The symmetric case is not shown.

z

x
y

y

y

x

x

z

z

Figure 3. A right roller-coaster at x and a left roller-coaster at z .
b
a

b
d

c

a
m

k

e

n

k

e
j

i

a
m

f

h
g

d
c

l

f

b

n

x

x

n

f

c

a

m
k
j

e

m
d

c

n

g

k

n

f

l
j

e

l

h

l

h
g

b

x
d

k
j

e

h
g

a
m

f

j
x

d
c

l

x

b

h
i

g

i

i

i

Figure 4. Splaying a node. Irrelevant subtrees are omitted for clarity.

• Search: Find the node containing the key using the usual algorithm, or its predecessor or
successor if the key is not present. Splay whichever node was found.
• Insert: Insert a new node using the usual algorithm, then splay that node.
• Delete: Find the node x to be deleted, splay it, and then delete it. This splits the tree into
two subtrees, one with keys less than x, the other with keys bigger than x. Find the node
w in the left subtree with the largest key (the inorder predecessor of x in the original tree),splay it, and finally join it to the right subtree.
x

x

w

w

w
Figure 5. Deleting a node in a splay tree.

Each search, insertion, or deletion consists of a constant number of operations of the form
walk down to a node, and then splay it up to the root. Since the walk down is clearly cheaper5

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

than the splay up, all we need to get good amortized bounds for splay trees is to derive goodamortized bounds for a single splay.
Believe it or not, the easiest way to do this uses the potential method. We define the rank of anode v to be blg size(v)c, and the potential of a splay tree to be the sum of the ranks of its nodes:XXΦ :=rank(v) =blg size(v)cv

v

It’s not hard to observe that a perfectly balanced binary tree has potential Θ(n), and a linear
chain of nodes (a perfectly unbalanced tree) has potential Θ(n log n).
The amortized analysis of splay trees boils down to the following lemma. Here, rank(v)denotes the rank of v before a (single or double) rotation, and rank0 (v) denotes its rank afterwards.
Recall that the amortized cost is defined to be the number of rotations plus the drop in potential.
The Access Lemma. The amortized cost of a single rotation at any node v is at most 1 +3 rank0 (v) − 3 rank(v), and the amortized cost of a double rotation at any node v is at most3 rank0 (v) − 3 rank(v).
Proving this lemma is a straightforward but tedious case analysis of the different types ofrotations. For the sake of completeness, I’ll give a proof (of a generalized version) in the next
section.
By adding up the amortized costs of all the rotations, we find that the total amortized cost of
splaying a node v is at most 1 + 3 rank0 (v) − 3 rank(v), where rank0 (v) is the rank of v after theentire splay. (The intermediate ranks cancel out in a nice telescoping sum.) But after the splay, v
is the root! Thus, rank0 (v) = blg nc, which implies that the amortized cost of a splay is at most
3 lg n − 1 = O(log n).
We conclude that every insertion, deletion, or search in a splay tree takes O(log n) amortized
time.
?

10.7

Other Optimality Properties

In fact, splay trees are optimal in several other senses. Some of these optimality properties follow
easily from the following generalization of the Access Lemma.
Let’s arbitrarily assign each node v a non-negative real weight w(v). These weights are notactually stored in the splay tree, nor do they affect the splay algorithm in any way; they are onlyused to help with the analysis. We then redefine the size s(v) of a node v to be the sum of theweights of the descendants of v, including v itself:s(v) := w(v) + s(right(v)) + s(left(v)).
If w(v) = 1 for every node v, then the size of a node is just the number of nodes in its subtree, as
in the previous section. As before, we define the rank of any node v to be r(v) = lg s(v), and thepotential of a splay tree to be the sum of the ranks of all its nodes:
Φ=Xr(v) =v

X

lg s(v)v

In the following lemma, r(v) denotes the rank of v before a (single or double) rotation, and r 0 (v)denotes its rank afterwards.

6

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

The Generalized Access Lemma. For any assignment of non-negative weights to the nodes,
the amortized cost of a single rotation at any node x is at most 1 + 3r 0 (x) − 3r(x), and theamortized cost of a double rotation at any node v is at most 3r 0 (x) − 3r(x).
Proof: First consider a single rotation, as shown in Figure 1.
1 + Φ0 − Φ = 1 + r 0 (x) + r 0 ( y) − r(x) − r( y)[only x and y change rank]0≤ 1 + r (x) − r(x)[r 0 ( y) ≤ r( y)]≤ 1 + 3r 0 (x) − 3r(x)[r 0 (x) ≥ r(x)]Now consider a zig-zag, as shown in Figure 2. Only w, x, and z change rank.
2 + Φ0 − Φ= 2 + r 0 (w) + r 0 (x) + r 0 (z) − r(w) − r(x) − r(z)000[only w, x, z change rank][r(x) ≤ r(w) and r 0 (x) = r(z)]≤ 2 + r (w) + r (x) + r (z) − 2r(x)= 2 + (r 0 (w) − r 0 (x)) + (r 0 (z) − r 0 (x)) + 2(r 0 (x) − r(x))
s0 (w)s0 (z)+ lg 0+ 2(r 0 (x) − r(x))= 2 + lg 0
s (x)
s (x)
s0 (x)/2≤ 2 + 2 lg 0
+ 2(r 0 (x) − r(x))
s (x)= 2(r 0 (x) − r(x))[s0 (w) + s0 (z) ≤ s0 (x), lg is concave]≤ 3(r 0 (x) − r(x))[r 0 (x) ≥ r(x)]Finally, consider a roller-coaster, as shown in Figure 3. Only x, y, and z change rank.
2 + Φ0 − Φ= 2 + r 0 (x) + r 0 ( y) + r 0 (z) − r(x) − r( y) − r(z)00

≤ 2 + r (x) + r (z) − 2r(x)00[only x, y, z change rank]0[r ( y) ≤ r(z) and r(x) ≥ r( y)]00= 2 + (r(x) − r (x)) + (r (z) − r (x)) + 3(r (x) − r(x))s(x)
s0 (z)= 2 + lg 0
+ lg 0+ 3(r 0 (x) − r(x))
s (x)
s (x)
s0 (x)/2+ 3(r 0 (x) − r(x))≤ 2 + 2 lg 0s (x)= 3(r 0 (x) − r(x))[s(x) + s0 (z) ≤ s0 (x), lg is concave]This completes the proof. ⁵

Observe that this argument works for arbitrary non-negative vertex weights. By adding up
the amortized costs of all the rotations, we find that the total amortized cost of splaying a node x
is at most 1 + 3r(root) − 3r(x). (The intermediate ranks cancel out in a nice telescoping sum.)This analysis has several immediate corollaries. The first corollary is that the amortizedsearch time in a splay tree is within a constant factor of the search time in the best possible static
⁵This proof is essentially taken verbatim from the original Sleator and Tarjan paper. Another proof technique,which may be more accessible, involves maintaining blg s(v)c tokens on each node v and arguing about the changes intoken distribution caused by each single or double rotation. But I haven’t yet internalized this approach enough toinclude it here.

7

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

binary search tree. Thus, if some nodes are accessed more often than others, the standard splay
algorithm automatically keeps those more frequent nodes closer to the root, at least most of thetime.
StaticPOptimality Theorem. Suppose each node x is accessed at least t(x) times, and let
T = x t(x). The amortized cost of accessing x is O(log T − log t(x)).
Proof: Set w(x) = t(x) for each node x.

For any nodes x and z, let dist(x, z) denote the rank distance between x and y, that is,
the number of nodes y such that key(x) ≤ key( y) ≤ key(z) or key(x) ≥ key( y) ≥ key(z). In
particular, dist(x, x) = 1 for all x.
Static Finger Theorem. For any fixed node f (‘the finger’), the amortized cost of accessing x is
O(lg dist( f , x)).
Proof: Set w(x) = 1/dist(x, f )2 for each node x. Then s(root) ≤r(x) ≥ lg w(x) = −2 lg dist( f , x).

P∞

i=1 2/i2= π2 /3 = O(1), and

Here are a few more interesting properties of splay trees, which I’ll state without proof.⁶
The proofs of these properties (especially the dynamic finger theorem) are considerably more
complicated than the amortized analysis presented above.
Working Set Theorem [16]. The amortized cost of accessing node x is O(log D), where D isthe number of distinct items accessed since the last time x was accessed. (For the first access tox, we set D = n.)Scanning Theorem [18]. Splaying all nodes in a splay tree in order, starting from any initialtree, requires O(n) total rotations.
Dynamic Finger Theorem [7, 6]. Immediately after accessing node y, the amortized cost ofaccessing node x is O(lg dist(x, y)).
?

10.8

Splay Tree Conjectures

Splay trees are conjectured to have many interesting properties in addition to the optimality
properties that have been proved; I’ll describe just a few of the more important ones.
The Deque Conjecture [18] considers the cost of dynamically maintaining two fingers l and r,
starting on the left and right ends of the tree. Suppose at each step, we can move one of these
two fingers either one step left or one step right; in other words, we are using the splay tree
as a doubly-ended queue. Sundar* proved that the total cost of m deque operations on an
n-node splay tree is O((m + n)α(m + n)) [17]. More recently, Pettie later improved this bound toO(mα∗ (n)) [15]. The Deque Conjecture states that the total cost is actually O(m + n).
The Traversal Conjecture [16] states that accessing the nodes in a splay tree, in the orderspecified by a preorder traversal of any other binary tree with the same keys, takes O(n) time.
This is generalization of the Scanning Theorem.
The Unified Conjecture [13] states that the time to access node x is O(lg min y (D( y)+d(x, y))),where D( y) is the number of distinct nodes accessed since the last time y was accessed. This
⁶This list and the following section are taken almost directly from Erik Demaine’s lecture notes [5].

8Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

would immediately imply both the Dynamic Finger Theorem, which is about spatial locality, and
the Working Set Theorem, which is about temporal locality. Two other structures are known thatsatisfy the unified bound [4, 13].
Finally, the most important conjecture about splay trees, and one of the most important open
problems about data structures, is that they are dynamically optimal [16]. Specifically, the cost of
any sequence of accesses to a splay tree is conjectured to be at most a constant factor more thanthe cost of the best possible dynamic binary search tree that knows the entire access sequence inadvance. To make the rules concrete, we consider binary search trees that can undergo arbitraryrotations after a search; the cost of a search is the number of key comparisons plus the numberof rotations. We do not require that the rotations be on or even near the search path. This is anextremely strong conjecture!
No dynamically optimal binary search tree is known, even in the offline setting. However,three very similar O(log log n)-competitive binary search trees have been discovered in the last
few years: Tango trees [9], multisplay trees [20], and chain-splay trees [12]. A recently-publishedgeometric formulation of dynamic binary search trees [8, 10] also offers significant hope for
future progress.

References[1] Arne Andersson*. Improving partial rebuilding by using simple balance criteria. Proc. Workshop on
Algorithms and Data Structures, 393–402, 1989. Lecture Notes Comput. Sci. 382, Springer-Verlag.
[2] Arne Andersson. General balanced trees. J. Algorithms 30:1–28, 1999.
[3] Jon L. Bentley and James B. Saxe*. Decomposable searching problems I: Static-to-dynamic transformation. J. Algorithms 1(4):301–358, 1980.
[4] Mihai Bădiou* and Erik D. Demaine. A simplified and dynamic unified structure. Proc. 6th
Latin American Sympos. Theoretical Informatics, 466–473, 2004. Lecture Notes Comput. Sci. 2976,
Springer-Verlag.
[5] Jeff Cohen* and Erik Demaine. 6.897: Advanced data structures (Spring 2005), Lecture 3, February
8 2005. 〈http://theory.csail.mit.edu/classes/6.897/spring05/lec.html〉.
[6] Richard Cole. On the dynamic finger conjecture for splay trees. Part II: The proof. SIAM J. Comput.
30(1):44–85, 2000.
[7] Richard Cole, Bud Mishra, Jeanette Schmidt, and Alan Siegel. On the dynamic finger conjecture for
splay trees. Part I: Splay sorting log n-block sequences. SIAM J. Comput. 30(1):1–43, 2000.
[8] Erik D. Demaine, Dion Harmon*, John Iacono, Daniel Kane*, and Mihai Pǎtraşcu. The geometry ofbinary search trees. Proc. 20th Ann. ACM-SIAM Symp. Discrete Algorithms, 496–505, 2009.
[9] Erik D. Demaine, Dion Harmon*, John Iacono, and Mihai Pătraşcu**. Dynamic optimality—almost.
Proc. 45th Annu. IEEE Sympos. Foundations Comput. Sci., 484–490, 2004.
[10] Jonathan Derryberry*, Daniel Dominic Sleator, and Chengwen Chris Wang*. A lower boundframework for binary search trees with rotations. Tech. Rep. CMU-CS-05-187, Carnegie Mellon Univ.,
Nov. 2005. 〈http://reports-archive.adm.cs.cmu.edu/anon/2005/CMU-CS-05-187.pdf〉.
[11] Igal Galperin* and Ronald R. Rivest. Scapegoat trees. Proc. 4th Annu. ACM-SIAM Sympos. Discrete
Algorithms, 165–174, 1993.
[12] George F. Georgakopoulos. Chain-splay trees, or, how to achieve and prove log log N -competitivenessby splaying. Inform. Proc. Lett. 106(1):37–43, 2008.
[13] John Iacono*. Alternatives to splay trees with O(log n) worst-case access times. Proc. 12th Annu.
ACM-SIAM Sympos. Discrete Algorithms, 516–522, 2001.
[14] Mark H. Overmars*. The Design of Dynamic Data Structures. Lecture Notes Comput. Sci. 156.
Springer-Verlag, 1983.
[15] Seth Pettie. Splay trees, Davenport-Schinzel sequences, and the deque conjecture. Proc. 19th Ann.
ACM-SIAM Symp. Discrete Algorithms, 1115–1124, 2008.

9

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13][16] Daniel D. Sleator and Robert E. Tarjan. Self-adjusting binary search trees. J. ACM 32(3):652–686,
1985.
[17] Rajamani Sundar*. On the Deque conjecture for the splay algorithm. Combinatorica 12(1):95–124,
1992.
[18] Robert E. Tarjan. Sequential access in splay trees takes linear time. Combinatorica 5(5):367–378,
1985.
[19] Robert Endre Tarjan. Data Structures and Network Algorithms. CBMS-NSF Regional Conference
Series in Applied Mathematics 44. SIAM, 1983.
[20] Chengwen Chris Wang*, Jonathan Derryberry*, and Daniel Dominic Sleator. O(log log n)-competitive
dynamic binary search trees. Proc. 17th Annu. ACM-SIAM Sympos. Discrete Algorithms, 374–383, 2006.
*Starred authors were graduate students at the time that the cited work was published. **Double-starredauthors were undergraduates.

Exercises
1. (a) An n-node binary tree is perfectly balanced if either n ≤ 1, or its two subtrees are
perfectly balanced binary trees, each with at most bn/2c nodes. Prove that I(v) ≤ 1
for every node v of any perfectly balanced tree.
(b) Prove that at most one subtree is rebalanced during a scapegoat tree insertion.
2. In a dirty binary search tree, each node is labeled either clean or dirty. The lazy deletion
scheme used for scapegoat trees requires us to purge the search tree, keeping all the clean
nodes and deleting all the dirty nodes, as soon as half the nodes become dirty. In addition,
the purged tree should be perfectly balanced.
(a) Describe and analyze an algorithm to purge an arbitrary n-node dirty binary searchtree in O(n) time. (Such an algorithm is necessary for scapegoat trees to achieve
O(log n) amortized insertion cost.)
? (b)

Æ

Modify your algorithm so that is uses only O(log n) space, in addition to the tree itself.
Don’t forget to include the recursion stack in your space bound.

(c) Modify your algorithm so that is uses only O(1) additional space. In particular, youralgorithm cannot call itself recursively at all.

3. Consider the following simpler alternative to splaying:
MoveToRoot(v):while parent(v) 6= Nullrotate at v

Prove that the amortized cost of MoveToRoot in an n-node binary tree can be Ω(n). Thatis, prove that for any integer k, there is a sequence of k MoveToRoot operations that
require Ω(kn) time to execute.
4. Let P be a set of n points in the plane. The staircase of P is the set of all points in the planethat have at least one point in P both above and to the right.

10

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

A set of points in the plane and its staircase (shaded).

(a) Describe an algorithm to compute the staircase of a set of n points in O(n log n) time.
(b) Describe and analyze a data structure that stores the staircase of a set of points, andan algorithm Above?(x, y) that returns True if the point (x, y) is above the staircase,or False otherwise. Your data structure should use O(n) space, and your Above?
algorithm should run in O(log n) time.
TRUE

FALSE

Two staircase queries.

(c) Describe and analyze a data structure that maintains a staircase as new points areinserted. Specifically, your data structure should support a function Insert(x, y)that adds the point (x, y) to the underlying point set and returns True or False toindicate whether the staircase of the set has changed. Your data structure should use
O(n) space, and your Insert algorithm should run in O(log n) amortized time.
TRUE!

FALSE!

Two staircase insertions.

5. Suppose we want to maintain a dynamic set of values, subject to the following operations:• Insert(x): Add x to the set (if it isn’t already there).
• Print&DeleteBetween(a, b): Print every element x in the range a ≤ x ≤ b, inincreasing order, and delete those elements from the set.
For example, if the current set is {1, 5, 3, 4, 8}, then• Print&DeleteBetween(4, 6) prints the numbers 4 and 5 and changes the set to{1, 3, 8};• Print&DeleteBetween(6, 7) prints nothing and does not change the set;
• Print&DeleteBetween(0, 10) prints the sequence 1, 3, 4, 5, 8 and deletes everything.
11

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13](a) Suppose we store the set in our favorite balanced binary search tree, using thestandard Insert algorithm and the following algorithm for Print&DeleteBetween:
Print&DeleteBetween(a, b):x ← Successor(a)while x ≤ bprint xDelete(x)x ← Successor(a)Here, Successor(a) returns the smallest element greater than or equal to a (or ∞if there is no such element), and Delete is the standard deletion algorithm. Provethat the amortized time for Insert and Print&DeleteBetween is O(log N ), where
N is the maximum number of items that are ever stored in the tree.
(b) Describe and analyze Insert and Print&DeleteBetween algorithms that run inO(log n) amortized time, where n is the current number of elements in the set.
(c) What is the running time of your Insert algorithm in the worst case?
(d) What is the running time of your Print&DeleteBetween algorithm in the worstcase?
6. Say that a binary search tree is augmented if every node v also stores size(v), the numberof nodes in the subtree rooted at v.
(a) Show that a rotation in an augmented binary tree can be performed in constant time.
(b) Describe an algorithm ScapegoatSelect(k) that selects the kth smallest item in an
augmented scapegoat tree in O(log n) worst-case time. (The scapegoat trees presented
in these notes are already augmented.)(c) Describe an algorithm SplaySelect(k) that selects the kth smallest item in an
augmented splay tree in O(log n) amortized time.
(d) Describe an algorithm TreapSelect(k) that selects the kth smallest item in an
augmented treap in O(log n) expected time.
7. Many applications of binary search trees attach a secondary data structure to each node in
the tree, to allow for more complicated searches. Let T be an arbitrary binary tree. The
secondary data structure at any node v stores exactly the same set of items as the subtreeof T rooted at v. This secondary structure has size O(size(v)) and can be built in O(size(v))
time, where size(v) denotes the number of descendants of v.
The primary and secondary data structures are typically defined by different attributesof the data being stored. For example, to store a set of points in the plane, we could define
the primary tree T in terms of the x-coordinates of the points, and define the secondary
data structures in terms of their y-coordinate.
Maintaining these secondary structures complicates algorithms for keeping the top-levelsearch tree balanced. Specifically, performing a rotation at any node v in the primary tree
now requires O(size(v)) time, because we have to rebuild one of the secondary structures(at the new child of v). When we insert a new item into T , we must also insert into one ormore secondary data structures.

12

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13](a) Overall, how much space does this data structure use in the worst case?
(b) How much space does this structure use if the primary search tree is perfectly
balanced?
(c) Suppose the primary tree is a splay tree. Prove that the amortized cost of a splay (andtherefore of a search, insertion, or deletion) is Ω(n). [Hint: This is easy!](d) Now suppose the primary tree T is a scapegoat tree. How long does it take to rebuild
the subtree of T rooted at some node v, as a function of size(v)?
(e) Suppose the primary tree and all secondary trees are scapegoat trees. What is theamortized cost of a single insertion?
? (f)Finally, suppose the primary tree and every secondary tree is a treap. What is theworst-case expected time for a single insertion?

8. Suppose we want to maintain a collection of strings (sequences of characters) under thefollowing operations:• NewString(a) creates a new string of length 1 containing only the character a andreturns a pointer to that string.
• Concat(S, T ) removes the strings S and T (given by pointers) from the data structure,adds the concatenated string S T to the data structure, and returns a pointer to the
new string.
• Split(S, k) removes the strings S (given by a pointer) from the data structure, adds
the first k characters of S and the rest of S as two new strings in the data structure,and returns pointers to the two new strings.
• Reverse(S) removes the string S (given by a pointer) from the data structure, adds
the reversal of S to the data structure, and returns a pointer to the new string.
• Lookup(S, k) returns the kth character in string S (given by a pointer), or Null if
the length of the S is less than k.
Describe and analyze a simple data structure that supports NewString and Reversein O(1) worst-case time, supports every other operation in O(log n) time (either worst-case,
expected, or amortized), and uses O(n) space, where n is the sum of the current string
lengths. [Hint: Why is this problem here?]
9. After the Great Academic Meltdown of 2020, you get a job as a cook’s assistant at Jumpin’
Jack’s Flapjack Stack Shack, which sells arbitrarily-large stacks of pancakes for just four
bits (50 cents) each. Jumpin’ Jack insists that any stack of pancakes given to one of his
customers must be sorted, with smaller pancakes on top of larger pancakes. Also, whenevera pancake goes to a customer, at least the top side must not be burned.
The cook provides you with a unsorted stack of n perfectly round pancakes, of ndifferent sizes, possibly burned on one or both sides. Your task is to throw out the pancakesthat are burned on both sides (and only those) and sort the remaining pancakes so that
their burned sides (if any) face down. Your only tool is a spatula. You can insert the spatula
under any pancake and then either flip or discard the stack of pancakes above the spatula.
More concretely, we can represent a stack of pancakes by a sequence of distinct integers
between 1 and n, representing the sizes of the pancakes, with each number marked to13

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13]

Flipping the top four pancakes. Again.

indicate the burned side(s) of the corresponding pancake. For example, 1 4 3 2 represents
a stack of four pancakes: a one-inch pancake burned on the bottom; a four-inch pancake
burned on the top; an unburned three-inch pancake, and a two-inch pancake burned
on both sides. We store this sequence in a data structure that supports the following
operations:• Position(x): Return the position of integer x in the current sequence, or 0 if x is
not in the sequence.
• Value(k): Return the kth integer in the current sequence, or 0 if the sequence has nokth element. Value is essentially the inverse of Position.
• TopBurned(k): Return True if and only if the top side of the kth pancake in thecurrent sequence is burned.
• Flip(k): Reverse the order and the burn marks of the first k elements of the sequence.
• Discard(k): Discard the first k elements of the sequence.
(a) Describe an algorithm to filter and sort any stack of n burned pancakes using O(n) of
the operations listed above. Try to make the big-Oh constant small.
1432

Flip(4)/ 2 3 4 1 Discard(1) / 3 4 1

Flip(2)/ 431

Flip(3)/ 134(b) Describe a data structure that supports each of the operations listed above in O(log n)amortized time. Together with part (a), such a data structure gives us an algorithm
to filter and sort any stack of n burned pancakes in O(n log n) time.
10. Let X = 〈x 1 , x 2 , . . . , x m 〉 be a sequence of m integers, each from the set {1, 2, . . . , n}. We
can visualize this sequence as a set of integer points in the plane, by interpreting eachelement x i as the point (x i , i). The resulting point set, which we can also call X , has exactly
one point on each row of the n × m integer grid.
(a) Let Y be an arbitrary set of integer points in the plane. Two points (x 1 , y1 ) and(x 2 , y2 ) in Y are isolated if (1) x 1 6= x 2 and y1 6= y2 , and (2) there is no other point(x, y) ∈ Y with x 1 ≤ x ≤ x 2 and y1 ≤ y ≤ y2 . If the set Y contains no isolated pairsof points, we call Y a commune.⁷
Let X be an arbitrary set of points on the n × n integer grid with exactly one point
per row. Show that there is a commune Y that contains X and consists of O(n log n)points.
⁷Demaine et al. [8] refer to communes as arborally satisfied sets.

14

Algorithms

Lecture 10: Scapegoat and Splay Trees [Fa’13](b) Consider the following model of self-adjusting binary search trees. We interpret X
as a sequence of accesses in a binary search tree. Let T0 denote the initial tree. In
the ith round, we traverse the path from the root to node x i , and then arbitrarily
reconfigure some subtree Si of the current search tree Ti−1 to obtain the next searchtree Ti . The only restriction is that the subtree Si must contain both x i and the rootof Ti−1 . (For example, in a splay tree, Si is the search path to x i .) The cost of the ith
access is the number of nodes in the subtree Si .
Prove that the minimum cost of executing an access sequence X in this model is
at least the size of the smallest commune containing the corresponding point set X .
[Hint: Lowest common ancestor.]? (c)Suppose X is a random permutation of the integers 1, 2, . . . , n. Use the lower boundin part (b) to prove that the expected minimum cost of executing X is Ω(n log n).

Æ(d) Describe a polynomial-time algorithm to compute (or even approximate up to constantfactors) the smallest commune containing a given set X of integer points, with at
most one point per row. Alternately, prove that the problem is NP-hard.

© Copyright 2018 Jeff Erickson.
This work is licensed under a Creative Commons License (http://creativecommons.org/licenses/by-nc-sa/4.0/).
Free distribution is strongly encouraged; commercial distribution is expressly forbidden.
See http://jeffe.cs.illinois.edu/teaching/algorithms for the most recent revision.

15