Dynamic Order Statistics

Most applications of binary search trees manipulate more than one key.
Example: In a database of PC’s, we want to know how many computers sell for between $1,000 and $1,500.
Let $T$ be a BST with $n$ nodes and let $i$ be an integer between 1 and $n$.
We say a node in $T$ has rank $i$ if it’s the $i$th smallest node in $T$.
The function select(i) returns the node with rank $i$.
The function rank(x) returns the rank of node x.
So we can use select to find the median of a data set.
We will extend binary search trees to handle these operations (as well as all previous ones) in time $O(h)$, where $h$ is the height of the tree.

Idea

Each node x has a field x.size equal to the number of descendants of x.
It’s easy to check that the rank of a node x equals
Σ { 1 + y.left.size : y = x or y = any ancestor of x containing x in its right subtree }
It’s convenient to have NIL node with NIL.size = 0.
This is even true for BST’s and splay trees.

rank(x): Climb up x’s access path, computing the above sum.
select(i): Starting at the root, descend to the node of rank i by maintaining the rank of the node we are at (using the above sum) and descending left if the rank is too big, right if too small.
insert: When adding a new leaf x, increase u.size by 1 for every node u on x’s access path.
delete: When splicing out node y, decrease u.size by 1 for every node u on y’s access path.

These algorithms extend to red-black trees, achieving time $O(\log n)$ worst-case time per operation for all operations.
Similarly, they extend to splay trees, giving $O(\log n)$ amortized time per operation.
The only additional change is when we do a rotation (in insert or delete).
A rotation only changes the size of 2 nodes.
It is easy to compute x.size for any node x using the identity
```
x.size = 1 + x.left.size + x.right.size
```

Sometimes we need to combine search trees, and also to break them up.
Procedure join(T1, x, T2): where T1 & T2 are search trees, and x is a node,
x.key is $\ge$ every key in T1, and $\le$ every key in T2.
join returns a search tree consisting of the keys in T1, T2, and x.
The operation is destructive: both T1 and T2 are destroyed.

Procedure split(T, x): where T is a search tree containing node x.
split returns search trees T1, T2 and node x, where T1 contains all nodes in T with key $<$ x.key, and T2 contains all nodes in T with key $>$ x.key.
We assume distinct keys.
This operation is also destructive.

Red-black trees can implement join, split, and all previous operations in time $O(\log n)$ worst-case time per operation.
Splay trees can implement them in time $O(\log n)$ amortized time per operation.
An example application of join is to use it to find a minimum spanning tree.