如何计算只有一个孩子的二叉树中的节点数？

Question

I have implemented the following function:

public int count(Node n) {
    if (n == null) {
        return 0;
    } else if (n.left == null && n.right != null) {
        return 1 + count(n.right);
    } else if (n.left != null && n.right == null) {
        return 1 + count(n.left);
    }
    return 0;
}

The problem is when I called it with:

System.out.println(tree.count(tree.root));

It only prints me the value of the root. What am I doing wrong?

Answer 1

Your code seems to have elements of both an instance method and a static method, which is a bit confusing. Choose one, and be consistent in similar methods. The simplest way is to use the bitwise xor ^ (returns true if exactly one of the two expressions are true )

This is a static method. Called using Node.countNonBranchingNodes(tree) :

public static int countNonBranchingNodes(Node n) {
    if (n == null) return 0;
    return (n.left != null ^ n.right != null ? 1 : 0) +
           countNonBranchingNodes(n.left) +
           countNonBranchingNodes(n.right);
}

If you want an instance method version, call this using tree.countNonBranchingNodes() :

public int countNonBranchingNodes() {
    int count = left != null ^ right != null ? 1 : 0;
    if (left != null) count += left.countNonBranchingNodes();
    if (right != null) count += right.countNonBranchingNodes();
    return count;
}

Answer 2

In your code, you forget to handle the node which has both left and right child, so your code should like this:

public int count(Node n) {
    if (n == null) {
        return 0;
    } else if (n.left == null && n.right != null) {
        return 1 + count(n.right);
    } else if (n.left != null && n.right == null) {
        return 1 + count(n.left);
    } else {
        return count(n.left) + count(n.right);
    }
}

Answer 3

In your code, you have not handled the case when node is having both left and right children. In that case we have to avoid that node to be counted but still we have to further proceed with counting in left and right subtrees. But in your solution, If the node if having both the children, then you are simply returning 0, that's not correct.

    public int countNodesWithExactlyOneChild(Node root){
        if(root == null) return 0;
        return (havingOneChild(root) ? 1 : 0) +
                   countNodesWithExactlyOneChild(root.left) + 
                   countNodesWithExactlyOneChild(root.right);

    }

    private boolean havingOneChild(Node node) {
        if(node != null && ((node.left == null && node.right != null) ||
            (node.left != null && node.right == null))) {
            return true;
        }
        return false;
    }

Answer 4

It seems your node will have 5 possibility:

"left only", "right only", "both left and right", "neither left nor right" and "null".

public int count(Node n) {
    // null
    if (n == null) {
        return 0;
    // right only
    } else if (n.left == null && n.right != null) {
        return 1 + count(n.right);
    // left only
    } else if (n.left != null && n.right == null) {
        return 1 + count(n.left);
    // both left and right
    } else if (n.left != null && n.right != null) {
        return count(n.left) + count(n.right);
    // neither left nor right
    } else if (n.left == null && n.right == null) {
        return 1;
    // any else missing?
    } else {
        throw new RuntimeException();
    }
}