计算二叉树的正确节点

Question

I want to count the right nodes of a binary tree, for example the following one:

    15
   /
10
   \
    14

so I made the following program:

public class NodeT {
    int elem;
    NodeT left;
    NodeT right;
    public NodeT(int elem){
        this.elem=elem;
        left=null;
        right=null;
    }
}


public class Tree {
    public NodeT createTree(){
        NodeT root=new NodeT(15);
        NodeT n1=new NodeT(10);
        NodeT n4=new NodeT(14);
        root.left=n1;
        n1.right=n4;
        return root;
    }
 public int countRight(NodeT root){
         if (root==null) return 0;    //version 1
         else{
             return 1+countRight(root.right);
         }
     }

I called my main program in the following way:

Tree tree=new Tree();
NodeT root=tree.createTree();
System.out.println(tree.countRight(root))

This code prints 1 as the correct answer, but I cannot understand why is this happening. For what I see the right branch of 15 is equal to null so the call to the recursive function countRight() should return 0 and print an incorrect answer.

I have seen other solutions and I found that for counting all the nodes they use solutions like the following:

     static int n;
     public int countRight(NodeT root){   //version 2
         if (root==null) return 0;
         if (root.left!=null){
             n=countRight(root.left);
         }
         if (root.right!=null){
             n++;
             n=countRight(root.right);
         }
         return n;
     }

which seems more legit to me. Could it be a case in which the first version fails?

Thanks

Answer 1

A method like that should never use a static field, or any field for that matter.

The task is to count the number of right nodes, which actually means to count the number of nodes where right is not null. You're not really counting the nodes, but the references to the nodes.

It also means you have to scan all the nodes, which means that the method must traverse both left and right.

Finally, the root node is by definition not a right node.

public int countRight(NodeT node) {
    if (node == null)
        return 0;
    if (node.right == null)
        return countRight(node.left);
    return 1 + countRight(node.left) + countRight(node.right);
}

Answer 2

your first code will retrun 2 no way it returns 1 recursively calling

return 1+another deeper call until root.right==null

will result in 2 return based on your structure the tree you coded is different than the one you draw

Answer 3

Suposing you can't debug, it would only return 0 if the parameter "NodeT root" was null.

I supose you want:

public int countRight(NodeT root, int currentDepth){
         if (root==null
            || root.right == null) // missing this comparison
             return currentDepth;
         else{
             return countRight(root.right, currentDepth++);
         }
     } 

Tree tree=new Tree();
NodeT root=tree.createTree();
System.out.println(tree.countRight(root), 0) // 0 is the begin