| Recursive Methods for Computing Size and Height |
In this section we start relating some terminological concepts that we learned
to recursive methods that operate on the binary trees defined in the
previous section.
We can write a very simple recursive method for computing the size of a binary
tree; it is simlar to (and generalizes) the recursive method that we studied
to compute the length of linked list.
public int size (TN t)
{
if (t == null)
return 0;
else
return 1 + size(t.left) + size(t.right);
}
Note that here (and in many other recursive methods operating on binary trees)
we write two recursive calls: one to compute the size of the left subtree
and one to compute the size of the right subtree.
We can prove that this method is correct as follows.
- For the base case (an empty tree) this method returns the correct size: 0
nodes.
- The recursive calls are applied to a strictly smaller trees (at least one
fewer nodes and of at least one smaller height: both integers that
characterize the size of a tree/problem).
- If size(t.left) and size(t.right) correctly compute the
number of nodes in the left and right subtrees of t, then
returning a value one bigger (for the root of this subtree) than the sum
of these values correctly computes the size of the entire list.
Note that without some kind of array or collection class, we CANNOT write this
code iteratively.
If we try to use one cursor (as opposed to an array or stack of cursors) once
we move to one subtree (say the left one) we have lost our reference to the
other (right) one.
As always, it would be useful to hand simulate this recursive method on a
small tree to understand its workings better.
In a hand simulation, calls would go up and down the call frames, unlike
linear (linked list) recursion, which tends to go down once and then back
to the top.
Here is a iterative method that uses a stack to compute the size of a tree
public int size (TN t)
{
AbstractStack s = new ArrayStack();
int size = 0;
s.add(t);
while (!s.isEmpty()) {
TN next = (TN)s.remove();
if (next != null) {
size++;
s.add(next.left);
s.add(next.right);
}
}
return size;
}
We can also write a recursive method to compute the height of tree.
First, we will do so in an intuitive manner; then we will write a smaller and
simpler to understand method using a bit more sophistication.
Note that height of a (sub)tree that is a leaf node is just 0.
Also note that the height of an internal node is 1 more than the biggest
height of its subtrees.
Using these facts we can write the following recursive method to compute the
height of any non-empty tree.
public int height (TN t)
{
if (t.left == null && t.right == null) //leaf check
return 0;
else if (t.left == null)
return 1 + height(t.right);
else if (t.right == null)
return 1 + height(t.left);
else
return 1 + Math.max(height(t.left),height(t.right));
}
This method deals with all the necessary cases: a leaf node, an internal node
with only a left (or only a right) subtree, and an internal node with both
left and right subtrees.
This method does not work on empty trees, which have no directly defined
height from the previous definition.
Now, let us simplify this code by defining the height of an empty tree to be
-1.
In one case this seems very strange, but in another it seems obvious: an empty
tree should have a height that is one less than a leaf node (whose height is
0).
By using this definition (and no others), we can simplify the height
method (as well as defininig it for all possible trees, even empty ones) into
the elegant method below.
public int height (TN t)
{
if (t == null)
return -1;
else
return 1 + Math.max(height(t.left),height(t.right));
}
Again, if t is a leaf node, then its left and right subtrees are empty,
so this method would preform the recursion and return
1 + Math.max(-1,-1) which returns 0 (the correct answer for a leaf
node).
So, using this generalization of height, our code is simpler and always works
(no matter whether an empty or non-empty tree is passed as a parameter; in
the earlier method, passing an empty tree has a parameter would cause Java
to throw a NullPointerException when it tried to determine
if the node was a leaf).
Mathematicians generalize definitions such as this one all the time.
You may or may not know that for a non-zero a, a0 is
defined as 1.
There are many ways to justify this definition (some quite complicated); the
simplest way is to note the algebraic law
axay = ax+y.
By this law (a quite useful one to have)
a0ax = a0+x = ax; which
means that a0 must be equal to 1 for this identity
to hold.
|
Then the number of nodes in the entire perfect tree is