了解二进制搜索树计数

Question

I am having trouble understanding how this Binary Search Tree method is counting nodes, I have looked at many examples online, however I cannot find one which will explain exactly what is happening.

Here is an example:

public int nodes() {
    int leftNodes = 0;

    if (left != null) {
        leftNodes = left.nodes();
    }
    int rightNodes = 0;

    if (right != null) {
        rightNodes = right.nodes();
    }
    return leftNodes + rightNodes + 1;
}

This is how I am understanding the process of this method, and maybe someone can help me understand where I'm going wrong.

1. The method is called from outside of itself from a BTS Object; "tree.nodes() etc".
2. int leftNodes is declared and set to 0.
3. If there is a left node (assume there is), then the value of leftNodes will be assigned to the return value of the call to nodes();
4. The recursive call will go through the nodes method again, assigning leftNodes to zero again.

So what I don't understand is where is the leftNodes variable being incremented? It seems like it's just recursing through the method again but the value doesn't change, and from how I see leftNodes and rightNodes will always be 0.

I found another example of BTS counting, this one using C++

int CountNodes(node*root)
{
if(root==NULL)
    return 0;
if(root->left!=NULL)
{
    n=n+1;
    n=CountNodes(root->left);
}
if(root->right!=NULL)
{
    n=n+1;
    n=CountNodes(root->right);
}
return n;
}

I find this method much easier to follow, as n is clearly being incremented everytime a node is found.

My question is how is the leftNodes/rightNodes value being incremented in the recursive call?

Answer 1

You should think about the end of the recursion.

Suppose you have a single node with no children.

Both left and right would be null , so you will make no recursive calls.

You'll return

leftNodes + rightNodes + 1; // 0 + 0 + 1 == 1

Now, suppose you have a simple tree that consists of a root, a left child and a right child.

When you call nodes() for the root of that tree, both left and right are not null, so we'll call both left.nodes() and right.nodes() . Since both the left and right children are leaf nodes (ie they have no children), the recursive calls for both will return 1, as explained above.

Therefore, when the recursive calls return, we'll return

leftNodes + rightNodes + 1; // 1 + 1 + 1 == 3

which is the number of nodes in our tree.

Answer 2

The variables leftNodes and rightNodes are local to the method nodes() which means that there is a different instance of these variables for each call of the method.

So when you call recursively the method (with left.nodes() for instance), the value of leftNodes is the same before and after the recursive call because it (the call) will have it's one instance of leftNodes (and rightNodes ).

Answer 3

This is a basic implementation of inorder traversal . For each node it goes to left child until there is no left child remaining (Because of recursion, think like in each visit of a node it is pushed to a stack). Then it repeats the same procedure for the top of the stack until there is no element left in the stack (Again note that, Stack is used to make things simpler compared to recursion). While doing so, it basically increments the total sum by one for each node it visits.