One of the most useful features of the tree data structure is that it can
grow dynamically. That is, at any point in your code, you can make a new
node and add it to the tree. Because of this you do not need to know the
number of nodes beforehand. As a result, our function which will provide
a new tree structure will need to allocate memory. Recall that we have
a `tree_t` data type, defined as follows:

typedef struct _tree {
int data;
struct _tree *left, *right;
} tree_t;

From this definition we can see that each node points to its left and right
children. To make our node creation function mesh easily with the rest of
our implementation, it should return a pointer to the memory we allocate.
Here is one possible way to implementation such a function:

tree_t *new_tree(int data)
{
tree_t *tree;
if ((tree = (tree_t *) malloc (sizeof(tree_t))) == NULL) {
return NULL;
}
tree->data = data;
tree->left = NULL;
tree->right = NULL;
return tree;
}

Alternatively, you could write a version where the caller is allowed to
specify the children.

tree_t *new_tree(int data; tree_t *left; tree_t *right)
{
tree_t *tree;
if ((tree = (tree_t *) malloc (sizeof(tree_t))) == NULL) {
return NULL;
}
tree->data = data;
tree->left = left;
tree->right = right;
return tree;
}

Since each node in the tree will necessarily be allocated dynamically,
it must also be freed when it is no longer needed. The following function
will take care of the freeing of an individual node.

void free_node (tree_t *tree)
{
if (tree != NULL) {
free(tree);
}
}

While it is useful to have a function that destroys an individual node,
it would be far more useful if we could make one function call to destroy
an entire tree. We mentioned in the introduction that trees are naturally
recursive. This function will take advantage of that feature. Destroying
a tree essentially requires destroying the tree headed by the left child and
the tree headed by the right child along with the root of the tree itself.
With that algorithm in mind, we produce the following function:

void destroy_tree (tree_t *tree)
{
if (tree == NULL)
return;
destroy_tree(tree->left);
destroy_tree(tree->right);
free_node(tree);
}

To break down the function above, we see that there is a base case for the
NULL tree, a recursive case for other trees, and finally a call to `free_node`
to destroy the tree's root. You will find that this is a pattern that recurs
frequently when writing functions to manipulate trees.

There are a few things to now consider. This implementation was based on
the data in each node being an integer. It is entirely possible, however,
to have each node contain some sort of dynamically allocated data. If you
wanted to do this, then the `new_tree` function would also have to allocate
space separately for the additional data. Furthermore, `free_node` would be
need to be modified to free memory allocated to the data elements in
addition to that allocated for the tree nodes.