Building a Binary Search Tree
In order to take advantage of the fast searching abilities of a binary
search tree, it is first necessary to put your data into this format.
For the following section, we will assume that we have the following
functions to access the data. In your programs this may mean reading
from a file or from standard input.
int data_remaining(void);
int next_data();
The first is a boolean that returns true while data remains and the second
will supply the next piece of data. Realize that the data is coming in no
particular order (ie. it is not presorted).
We want to build the tree with the following algorithm. We will read in a
piece of data, find the appropriate place to add it into the tree (meaning
we'll find a leaf that could have this piece of data as a child) and then
add the data element in that spot.
First we will write a function that determines where the data element should
be added to the tree. The return from the function will be the memory
address where the data element should be stored. This means that if we find
that the appropriate storage location is the right child of tree
t, we
would return
&(t->right). The algorithm consists of
walking left or
right down the tree according to whether the data element is greater than or
less than the data in the current node. We will also assume that the data is
all unique, so there is no chance of the same number appearing more than once.
It's possible to handle multiple instances of the same data element, but
we'll ignore this situation for simplicity's sake.
tree_t insertion_location(tree_t *t, int data)
{
if (t == NULL) {
return NULL;
}
tree_t holder;
/* Recursively find the insertion location. */
if (data < t->data) {
/*
* Search for an insertion location further down the tree.
* If one isn't found, the insertion location should be
* the left pointer of t.
*/
holder = insertion_location (t->left);
if(holder) {
return holder;
} else {
return &(t->left);
}
} else {
/*
* Search for an insertion location further down the tree.
* If one isn't found, the insertion location should be
* the right pointer of t.
*/
holder = insertion_location (t->right);
if(holder) {
return holder;
} else {
return &(t->right);
}
}
}
If insertion_location returns null, whatever tree was passed as the argument
should instead point to a new tree with that data element. Note that when
walking through the tree, if suffices to check if the number is less than the
data in the current node to determine whether it belongs in the left or the
right subtree.
Now that we have written the more complex recursive part, we simply need to
write the iterative function that calls the recursive one to build the tree.
tree_t *build_tree(void)
{
int data;
tree_t *t, *new_tree, *insert_point;
while (data_remaining()) {
data = next_data();
if((new_tree = new_tree(data)) == NULL) {
return NULL;
}
insert_point = insertion_location(t, data);
if (insert_point == NULL) {
t = new_tree;
} else {
*insert_point = new_tree;
}
}
return t;
}
Notice that whenever we call a function that returns dynamically allocated
memory, it is always necessary to check for the possibility that allocation
failed and returned a NULL pointer. The only time that insert_point will
be NULL is when ~insertion_location~ is called for the first time, with a
NULL pointer, that is, before there is anything in the tree.
