A binary search tree is said to be weightbalanced if half the nodes are on the left of the root, and half on the right. An αweightbalanced node is defined as meeting a relaxed weight balance criterion:
size(left) <= α*size(node)
size(right) <= α*size(node)
Where size can be defined recursively as:
function size(node)
if node = nil
return 0
else
return size(node>left) + size(node>right) + 1
end
An α of 1 therefore would describe a linked list as balanced, whereas an α of 0.5 would only match almost complete binary trees.
A binary search tree that is αweightbalanced must also be αheightbalanced, that is
height(tree) <= log
_{1/α}(NodeCount) + 1
Scapegoat trees are not guaranteed to keep αweightbalance at all times, but are always loosely αheightbalanced in that
height(scapegoat tree) <= log
_{1/α}(NodeCount) + 1
This makes scapegoat trees similar to redblack trees in that they both have restrictions on their height. They differ greatly though in their implementations of determining where the rotations (or in the case of scapegoat trees, rebalances) take place. Whereas redblack trees store additional 'color' information in each node to determine the location, scapegoat trees find a scapegoat which isn't αweightbalanced to perform the rebalance operation on. This is loosely similar to AVL trees, in that the actual rotations depend on 'balances' of nodes, but the means of determining the balance differs greatly. Since AVL trees check the balance value on every insertion/deletion, it is typically stored in each node; scapegoat trees are able to calculate it only as needed, which is only when a scapegoat needs to be found.
Unlike most other selfbalancing search trees, scapegoat trees are entirely flexible as to their balancing. They support any α such that 0.5 < α < 1. A high α value results in fewer balances, making insertion quicker but lookups and deletions slower, and vice versa for a low α. Therefore in practical applications, an α can be chosen depending on how frequently these actions should be performed.
Insertion is implemented with the same basic ideas as an unbalanced binary search tree, however with a few significant changes.
When finding the insertion point, the depth of the new node must also be recorded. This is implemented via a simple counter that gets incremented during each iteration of the lookup, effectively counting the number of edges between the root and the inserted node. If this node violates the αheightbalance property (defined above), a rebalance is required.
To rebalance, an entire subtree rooted at a scapegoat undergoes a balancing operation. The scapegoat is defined as being an ancestor of the inserted node which isn't αweightbalanced. There will always be at least one such ancestor. Rebalancing any of them will restore the αheightbalanced property.
One way of finding a scapegoat, is to climb from the new node back up to the root and select the first node that isn't αweightbalanced.
Climbing back up to the root requires O(log n) storage space, usually allocated on the stack, or parent pointers. This can actually be avoided by pointing each child at its parent as you go down, and repairing on the walk back up.
To determine whether a potential node is a viable scapegoat, we need to check its αweightbalanced property. To do this we can go back to the definition:
size(left) <= α*size(node)
size(right) <= α*size(node)
However a large optimisation can be made by realising that we already know two of the three sizes, leaving only the third having to be calculated.
Consider the following example to demonstrate this. Assuming that we're climbing back up to the root:
size(parent) = size(node) + size(sibling) + 1
But as:
size(inserted node) = 1.
The case is trivialized down to:
size[x+1] = size[x] + size(sibling) + 1
Where x = this node, x + 1 = parent and size(sibling) is the only function call actually required.
Once the scapegoat is found, the subtree rooted at the scapegoat is completely rebuilt to be perfectly balanced. This can be done in O(n) time by traversing the nodes of the subtree to find their values in sorted order and recursively choosing the median as the root of the subtree.
As rebalance operations take O(n) time (dependent on the number of nodes of the subtree), insertion has a worstcase performance of O(n) time. However, because these worstcase scenarios are spread out, insertion takes O(log n) amortized time.
Define the Imbalance of a node v to be the absolute value of the difference in size between its left node and right node minus 1, or 0, whichever is greater. In other words:
I
(
v
)
=
max
(

left
(
v
)
−
right
(
v
)

−
1
,
0
)
Immediately after rebuilding a subtree rooted at v, I(v) = 0.
Lemma: Immediately before rebuilding the subtree rooted at v,
I
(
v
)
=
Ω
(

v

)
(
Ω
is Big O Notation.)
Proof of lemma:
Let
v
0
be the root of a subtree immediately after rebuilding.
h
(
v
0
)
=
log
(

v
0

+
1
)
. If there are
Ω
(

v
0

)
degenerate insertions (that is, where each inserted node increases the height by 1), then
I
(
v
)
=
Ω
(

v
0

)
,
h
(
v
)
=
h
(
v
0
)
+
Ω
(

v
0

)
and
log
(

v

)
≤
log
(

v
0

+
1
)
+
1
.
Since
I
(
v
)
=
Ω
(

v

)
before rebuilding, there were
Ω
(

v

)
insertions into the subtree rooted at
v
that did not result in rebuilding. Each of these insertions can be performed in
O
(
log
n
)
time. The final insertion that causes rebuilding costs
O
(

v

)
. Using aggregate analysis it becomes clear that the amortized cost of an insertion is
O
(
log
n
)
:
Ω
(

v

)
O
(
log
n
)
+
O
(

v

)
Ω
(

v

)
=
O
(
log
n
)
Scapegoat trees are unusual in that deletion is easier than insertion. To enable deletion, scapegoat trees need to store an additional value with the tree data structure. This property, which we will call MaxNodeCount simply represents the highest achieved NodeCount. It is set to NodeCount whenever the entire tree is rebalanced, and after insertion is set to max(MaxNodeCount, NodeCount).
To perform a deletion, we simply remove the node as you would in a simple binary search tree, but if
NodeCount <= α*MaxNodeCount
then we rebalance the entire tree about the root, remembering to set MaxNodeCount to NodeCount.
This gives deletion its worstcase performance of O(n) time; however, it is amortized to O(log n) average time.
Suppose the scapegoat tree has
n
elements and has just been rebuilt (in other words, it is a complete binary tree). At most
n
/
2
−
1
deletions can be performed before the tree must be rebuilt. Each of these deletions take
O
(
log
n
)
time (the amount of time to search for the element and flag it as deleted). The
n
/
2
deletion causes the tree to be rebuilt and takes
O
(
log
n
)
+
O
(
n
)
(or just
O
(
n
)
) time. Using aggregate analysis it becomes clear that the amortized cost of a deletion is
O
(
log
n
)
:
∑
1
n
2
O
(
log
n
)
+
O
(
n
)
n
2
=
n
2
O
(
log
n
)
+
O
(
n
)
n
2
=
O
(
log
n
)
Lookup is not modified from a standard binary search tree, and has a worstcase time of O(log n). This is in contrast to splay trees which have a worstcase time of O(n). The reduced node memory overhead compared to other selfbalancing binary search trees can further improve locality of reference and caching.