Eternally Confuzzled

This site is the only or best resource.

## Binary Search Trees II (C): Introduction to binary search tree balancing In Binary Search Trees I you learned that binary search trees are a powerful data structure for storage and retrieval of data. Binary search trees are conveniently simple for simple operations, and more complicated operations are made possible, though not always simple, especially when rotations or other structural modifications are involved. I also hinted that the basic binary search tree algorithms have exceptionally bad performance in certain situations. There are three worst cases corresponding to data being input in ascending sorted order:

```  A
\
B
\
C
\
D
\
E```

Data being inserted in descending sorted order:

```          E
/
D
/
C
/
B
/
A```

Or data being inserted in alternating, outside-in order:

```  A
\
E
/
B
\
D
/
C```

None of these make for particularly efficient binary search trees because they are all structurally equivalent to linked lists. The result of all of this is that the good O(log N) performance of binary search trees degenerates to O(N). Because binary search trees are best used for large data sets, this can result in severe performance problems. Unfortunately, the classic methods for maintaining an optimal tree are frighteningly complicated. A simple solution is to recognize the performance of the average case of a binary search tree.

Performance of a basic binary search tree is O(log N) on average. The average case is when the data being inserted is sufficiently random to create what is called a randomized binary search tree, where the each new item has a 1/N probability of being placed at the root in any subtree:

The most obvious way to create a randomized binary search tree is to permute the input randomly. However, most times we don’t have access to all of the input at any given time. In fact, usually we will be inserting items one at a time into the tree from a stream or object factory. This makes it very difficult to permute the data before inserting it into the tree.

A randomized binary search tree can be created if every item in the data set has an equal probability of being the root item. This suggests the use of the root insertion routines devised in the last tutorial. At every point in the insertion, make a random selection of root insertion or basic insertion. The end result will be a randomized binary search tree. The algorithm is sound, an surprisingly easy to write. For this implementation of a randomized binary search tree insertion, we will be using the jsw_node and jsw_tree structures defined in the previous tutorial:

```struct jsw_node
{
int data;
};

struct jsw_tree
{
struct jsw_node *root;
size_t size;
};```

Consider, if you will, a simple recursive insertion, much like the pair of functions shown in Binary Search Trees I:

```struct jsw_node *jsw_insert_r(struct jsw_node *root, struct jsw_node *item, int key)
{
if (root == NULL)
{
root = item;
}
else
{
int dir = root->data < key;

}

return root;
}

void jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
tree->root = jsw_insert_r(tree->root, item, key);
++tree->size;
}```

Assuming a sorted sequence of keys, a degenerate tree is sure to be the result of running this algorithm. However, two simple changes will reduce the probability of that degenerate tree to a vanishingly small number. The first modification is the addition of the size argument to jsw_insert_r, which will be given the initial value of tree->size in jsw_insert. For each recursive call to jsw_insert_r, half of sz would be passed to give a rough estimate of the number of items in the subtree.

The second modification is to perform an insertion at the root, with the current subtree as the root to insert at. This root insertion would be made only with a probability of 1/sz. All in all, assuming the existence of jsw_root_insert, the changes to jsw_insert_r and jsw_insert look like this:

```struct jsw_node *jsw_insert_r(struct jsw_node *root, struct jsw_node *item, int key, int sz)
{
if (root == NULL)
{
root = item;
}
else if (rand() % (sz + 1) == sz) /* Probability 1/sz */
{
root = jsw_root_insert(root, item, key);
}
else
{
int dir = root->data < key;

}

return root;
}

void jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
tree->root = jsw_insert_r(tree->root, item, key, tree->size);
++tree->size;
}```

This use of random numbers is likely to be inferior, and it is used only for simplicity. For a thorough discussion on the merits of various random number implementations and uses, see the Random Numbers tutorial. For now, using the standard library rand function with modulus will serve our purposes.

Assuming the existence of jsw_root_insert is all well and good when brainstorming, but a concrete implementation would be helpful in real code. Without going into too much detail, here’s one example of how to do it:

```struct jsw_node *jsw_root_insert(struct jsw_node *root, struct jsw_node *item, int key)
{
if (root == NULL)
{
root = item;
}
else
{
struct jsw_node *save;
int dir = root->data < key;

/* Rotate on root */
root = save;
}

return root;
}```

These functions cover no new ground. Anyone who has read Binary Search Trees I should have no trouble with them.

An alternative to inserting as normal and then lifting the new item to a selected root with probability is splicing the subtree with probability. This is the method used by the “official” randomized binary search tree data structure as described by Martinez and Roura. The top level insertion algorithms are not much changed and familiar:

```struct jsw_node *jsw_insert_r(struct jsw_node *root, struct jsw_node *item, int key)
{
int n = (root == NULL) ? 0 : root->size;

if (rand() % (n + 1) == n)
{
return jsw_root_insert(root, item);
}
else
{
int dir = root->data < key;

++root->size;
}

return root;
}

void jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
tree->root = jsw_insert_r(tree->root, item, key);
}```

Instead of waiting until root is NULL to perform the insertion, the probability test is the sole factor in determining a location to insert. Note that when root is a terminal node, n will be 0 and the probability test will succeed, thus simulating the common leaf insertion. This ensures that the edge case of inserting at a terminal node is satisfied.

The splicing operation will be done in jsw_root_insert with the aid of a helper function called jsw_splitjsw_root_insert does not perform any searching; instead, it simply makes room for the new item and splices it into the tree at the chosen root. This can be a tricky operation because it must be guaranteed that the tree will remain a valid binary search tree. Therefore, jsw_split must be recursive as well, so that it can clean up any subtrees of the new root. Naturally, jsw_split does not have to be recursive, but this is a case where recursion makes life easier:

```void jsw_split(struct jsw_node *root, struct jsw_node *item, struct jsw_node **s, struct jsw_node **g)
{
if (root == NULL)
{
*s = *g = NULL;
}
else if (item->data < root->data)
{
*g = root;
}
else
{
*s = root;
}
}

struct jsw_node *jsw_root_insert(struct jsw_node *root, struct jsw_node *item)
{
struct jsw_node *s, *g;

jsw_split(root, item, &s, &g);

root = item;
root->size = 1;

root->size += s == NULL ? 0 : s->size;
root->size += g == NULL ? 0 : g->size;

return root;
}```

This implementation of jsw_root_insert is very simple in that it hands off most of the work to jsw_splitjsw_root_insert simply takes the results of jsw_split and assigns them to root, then ensures that the sizes are properly adjusted to match the structural changes to the subtree. jsw_split is somewhat tricky in how it recursively maintains a valid search tree structure. Consider the following tree:

```   b
/ \
a   e
/ \
d   g```

Let’s say we want to insert c into the tree. jsw_split needs to make room for c without breaking the binary search tree invariant. This is done by separating the two subtrees of the new node without breaking the invariant. Here is a sample execution of splitting the subtrees to fit c in. The most important part to understanding this algorithm is recognizing that each recursive call uses a child of either s or g. (! represents the current node, ? is an indeterminate pointer, and ~ is a null pointer):

```   b! <-----(s)
/ \
a   e
/ \
d   g

b <------(s)
/ \
a   e! <---(g)
/ \
d   g

b <------(s)
/ \
a   e <----(g)
/ \
d!  g
^
|

b <------(s)
/ \
a   e <----(g)
/ \
d   g
/^
~!|
|

b <------(s)
/ \
a   e <----(g)
/ \
d   g
/^
~!|
^ |
|

After jsw_split has divided up the tree, the pieces look something like the following diagram. Now, jsw_root_insert only has to use s and g to restructure the tree. Follow along yourself using the code to see how the end result is correct:

```  (s)    (g)
b      e      c
/ \    / \    / \
a   ~  d   g  ~   ~

c
/   \
b     e
/ \   / \
a   ~ d   g```

All of this trickery is, of course, meant to maintain the binary search tree invariant that every item is greater than the values in its left subtree and less the values in its right subtree. Without it, we would be forced to use leaf insertion and rotations to avoid the difficult problem of correctly splicing in a binary search tree.

Note that jsw_insert allows duplicate keys with this implementation. There are several ways of disallowing duplicates, ranging from the simple but somewhat inefficient to the complicated but very fast. With splicing, the easiest solution by far is to call jsw_find before ever performing the insertion:

```int jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
if (jsw_find(tree, key))
{
return 0;
}

tree->root = jsw_insert_r(tree->root, item, key);

return 1;
}```

Removal from this style of randomized binary search tree is “simply” the inverse of splitting called, creatively, join. The code for jsw_remove is a comfortable algorithm at this point:

```struct jsw_node *jsw_remove_r(struct jsw_node *root, struct jsw_node **old_item, int key)
{
struct jsw_node *save;

if (root != NULL)
{
if (key == root->data)
{
*old_item = root;
root = save;
}
else
{
int dir = root->data < key;

--root->size;
}
}

return root;
}

int jsw_remove(struct jsw_tree *tree, struct jsw_node **old_item, int key)
{
if (!jsw_find(tree, key))
{
return 0;
}

tree->root = jsw_remove_r(tree->root, old_item, key);

return 1;
}```

What jsw_join does is remove root from the structure and reconnect the broken links into a valid binary search tree using probability such that the randomness of the tree can be maintained. The code is short, but may not be immediately obvious:

```struct jsw_node *jsw_join(struct jsw_node *left, struct jsw_node *right)
{
int ln = left == NULL ? 0 : left->size;
int rn = right == NULL ? 0 : right->size;

if (ln + rn == 0)
{
return NULL;
}
else if (rand() % (ln + rn) < ln)
{
left->size += rn;
return left;
}
else
{
right->size += ln;
return right;
}
}```

To map the execution of jsw_join, we will use a similar tree as with jsw_split, except this time removing e instead of adding c at e:

```   b
/ \
a   g
/ \
d   h
\
e```

Given the left and right links of g (d and h), jsw_join first checks to see if g was a terminal node by testing the sum of its subtree’s sizes. If g was a terminal node, we could simply replace it with NULL and terminate. However, in this case g has two children, so more work is required. Using the same probability as with insertion (1/sz), jsw_join calls itself recursively, looking for a valid replacement based on the probability test. Assuming the right path is chosen, the resulting tree looks like this:

```   b
/ \
a   d
\
e
\
h```

Had the left path been chosen, the final structure would be:

```   b
/ \
a   h
/
d
\
e```

Because tracing this execution is a trivial exercise, and tracing recursive algorithms is good practice, I leave it to you to figure out how the algorithm gets to the final structure.

#### Treaps

The aptly named treap is a data structure that maintains both the invariant for a binary search tree and the invariant for a heap. When the priority for the heap is a randomly generated number, the result is a surprisingly well balanced randomized binary search tree. A treap must conform to two hard rules:

Binary search tree invariant (for u with a left child v and a right child w):

`v->data < u->data < w->data`

Heap invariant:

`w->priority < v->priority < u->priority`

By assigning priorities randomly or by hashing the data and then maintaining both the binary search tree condition and the heap condition, we have an excellent chance of getting a well balanced binary search tree. The worst case will still be O(n), as with all randomized binary search trees, but the chances of seeing that case are rather slim. In cases where guaranteed best case isn’t necessary, a treap will perform adequately and has the benefit of being easy to implement.

#### Insertion

Insertion into a treap is straightforward. With a new item and a random priority, simply perform a normal binary search tree insertion and then walk back up the tree performing rotations until the heap condition is met. This is one of the two relatively simple options for inserting a new item into a binary search tree other than at a leaf. By using rotations we can guarantee that the binary tree invariant will remain valid. However, a few changes will need to be made to the original jsw_node:

```struct jsw_node
{
int priority;
int data;
};

struct jsw_node NullItem = { &NullItem, &NullItem, RAND_MAX, 0 };
struct jsw_node *Null = &NullItem;

struct jsw_tree
{
struct jsw_node *root;
};```

Notice the added priority member. Of immediate notice is the fact that I have defined two global variables of jsw_node, an instance initialized to boundary values and a pointer initialized to the address of the instance. Our treap will be using Null to mark a terminal node rather than a null pointer as has been used thusfar. This may seem like an unnecessary change, but it greatly simplifies the removal algorithm we will be using.

The recursive algorithm to implement jsw_insert as a treap is simplicity itself:

```struct jsw_node *jsw_insert_r(struct jsw_node *root, struct jsw_node *item, int key)
{
if (root == Null)
{
root = item;
}
else
{
int dir = root->data < key;

{

root = save;
}
}

return root;
}

void jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
tree->root = jsw_insert_r(tree->root, item, key);
}```

This function is painfully simple. The only potentially confusing part is the use of dir to determine a right or left rotation, though once the idiom is understood, it actually results in shorter and simpler code. You can avoid this complexity by using two cases instead if you so choose:

```if (key < root->data)
{

{

root = save;
}
}
else
{

{

root = save;
}
}```

Of course, that defeats the purpose of using the link array in jsw_node, though it does conform to the traditionally accepted design of binary search trees found in books and classrooms.

Using the lessons of Binary Search Trees I, the astute reader may discover that the treap insertion algorithm bears a striking similarity to basic root insertion. This leads the way to a non-recursive algorithm with no trouble at all:

```int jsw_insert(struct jsw_tree *tree, struct jsw_node *item, int key)
{
struct jsw_node *walk;
struct jsw_node *up;
int dir;
int top = 0;

/* Handle empty tree case */
if (tree->root == Null)
{
tree->root = item;
return 1;
}

/* Search for an empty link */
walk = tree->root;

for (;;)
{
if (walk->data == key)
{
return 0;
}

dir = walk->data < key;

{
break;
}

up[top++] = walk;
}

/* Insert the new item */

/* Walk back up and rotate */
while (item != tree->root)
{
if (walk->priority > item->priority)
{
break;
}

/* Notify the rest of the tree of changes */
if (top > 0 && up[top - 1] != Null)
{
dir = (walk == up[top - 1]->link);
}

/* Reseat root if needed */
if (tree->root == walk)
{
tree->root = item;
}

/* Move up and start over */
walk = up[--top];
}

return 1;
}```

It should be obvious that this is a cut and paste from Binary Search Trees I with a few minor modifications to maintain the heap invariant. What could be easier than stealing existing code and mangling it to suit your needs?

#### Removal

Removal of a node is not as important as insertion, and many texts omit the code for it. While I can sympathize, I prefer to give at least a little working code whenever it would be of benefit. This feeling stems from trying in vain to weed out useful code snippets for removal algorithms when learning data structures myself. The algorithm for removing from a treap is exactly the opposite of insertion, as surprising as that may be. Find the item and perform rotations (walking the item down the tree) until it is a leaf, then remove it. This operation is typically called “pushdown”, once again proving that computer scientists have very little imagination. The algorithm is short:

```struct jsw_node *jsw_remove_r(struct jsw_node *root, struct jsw_node **old_item, int key)
{
if (root != Null)
{
struct jsw_node *save;

if (key == root->data)
{

root = save;

if (root != Null)
{
root = jsw_remove_r(root, old_item, key);
}
else
{
}
}
else
{
int dir = root->data < key;

}
}

return root;
}

void jsw_remove(struct jsw_tree *tree, struct jsw_node **old_item, int key)
{
tree->root = jsw_remove_r(tree->root, old_item, key);
}```

The search is simple: If root is not a terminal node, move left or right accordingly. Otherwise perform the appropriate rotation and continue to recurse as long as root is not a terminal node. If root is a terminal node, then a simple replacement with Null will be sufficient to remove it from the tree. After removing the item, the algorithm must then walk back up the search path and repair any unraveled links.

By studying this code, you can see why I chose to use a sentinel instead of a null pointer to mark terminal nodes. If I had used a null pointer, the following section of code Would surely break because root is dereferenced in the case where it is an invalid item.

```if (root != Null)
{
root = jsw_remove_r(root, old_item, key);
}
else
{