1

I am trying to write a method that will return true if a binary tree is full (each node has 2 child nodes or none) and false otherwise. This is working some of the time but not all. Any suggestions about where I am going wrong?

public static void testNum4()
    {
        System.out.println("How many nodes do you want in your tree?");
        int num=sc.nextInt();
        //TreeNode<Integer> root = TreeUtil.createBalancedNumberTree(num);  Use to test for a balanced tree
        TreeNode<Integer> root = TreeUtil.createIntegerTree(num);
        TreeUtil.displayTreeInWindow(root);
        System.out.println(isFull(root));
        TreeUtil.displayTreeInWindow (root);
    }

    public static boolean isFull(TreeNode<Integer>  root) {
    // pre: root of tree, 0 or more nodes
    // post: returns true if the input tree is a full tree; false otherwise

        if (root!=null) {
            if ((root.getLeft() != null && root.getRight() != null) || (root.getRight() == null && root.getLeft() == null))
            {
                return true;
            }
            else if (root.getLeft()!=null)
            {
                isFull(root.getLeft());
            }
            else if (root.getRight()!=null)
            {
                isFull(root.getRight());
            }
            else 
                return false;

        }
            return false;
    }
Improve this question
3
  • Can you say your problem clearly? Commented Apr 7, 2015 at 13:02
  • If the tree is complete, I will always get true. However, if it is incomplete sometimes I get true (which is wrong) and sometimes false. Commented Apr 7, 2015 at 13:04
  • 1
    The first if condition is nor correct. If a node(root) has 2 children then you return true without checking them recursively Commented Apr 7, 2015 at 13:05

6 Answers 6

Reset to default
3

Definition: a binary tree T is full if each node is either a leaf or possesses exactly two child nodes.

public static boolean isFull(TreeNode<Integer>  root)
// pre: root of tree, 0 or more nodes
// post: returns true if the input tree is a full tree; false otherwise
{

    if (root!=null)
    {
        if(root.getRight() == null && root.getLeft() == null)
        {
             return true;
        }
        if ((root.getRight() != null && root.getLeft() != null))
        {
            return isFull(root.getLeft())&&isFull(root.getLeft());
        }
    }
    return false;
}
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

So where is the leaf test? i.e. both left and right are null?
@weston your answer is right,but if the RIGHT node is null but the LEFT one isn't(may be a deep child tree),it will run a little slowly.
It's a good point. Better to put it as a comment on my answer though so someone looking at my answer would spot that.
1

Try to add return to each statement.

    else if (root.getLeft()!=null  && root.getRight()!=null)
    {
        return isFull(root.getLeft()) && isFull(root.getRight());
   }

Also, if the root node is null, then your tree is full. So the last return should be return true;

Improve this answer

1 Comment

So, if the left is full, don't even look at the right?
1

The problem is the else if and lack of return statements. Also no need to checking for null so much, and use of a method makes it more readable.

public static boolean isFull(TreeNode<Integer> node) {

    if (node == null) return false;

    if (isLeaf(node)) return true;

    return isFull(node.getLeft()) && isFull(node.getRight());
}

public static boolean isLeaf(TreeNode<Integer> node) {
    return node.getRight() == null && node.getLeft() == null;
}
Improve this answer

Comments

0

You are not fully traversing the tree. Use recursion to hit all the nodes. Check the root node. If there are no children, return true. If there are children, make sure there are two, and then check each of them recursively.

Improve this answer

Comments

0

I think that the if statements should be as follows:

if (root.getRight() == null && root.getLeft() == null)
{
    // The node has no children (full)
    return true;
}
else if (root.getLeft() != null && root.getRight() != null)
{
    // There are two children. Tree is only full if both sub trees are full
    return isFull(root.getLeft()) && isFull(root.getRight());
}
else 
{
    // Only one child
    return false;
}
Improve this answer

Comments

0

All the algoritms above return true in this case (as they shouldn't): complete binary tree . So, hope this helps:

//-1 means "false"
public boolean full() {
    int high = 0;
    return ( root != null && isFull(root, high) != -1 );
}

public boolean isLeaf() {
    return node.getRight() == null && node.getLeft() == null;
}

private int isFull(TreeNode<T> node, int high)
{
    ++high;
    if (node.isLeaf())
        return high;
    else
    {
        int hLeft=0, hRight=0;
        if(node.getLeft() != null)
            hLeft = isFull(node.getLeft(), high);
        if(node.getRight() != null)
            hRight = isFull(node.getRight, high);

        if ( (hLeft == hRight) && (hLeft != -1) )
            return ++high;
        return -1;
    }
}
Improve this answer

3 Comments

All the algoritms [sic] above return true in this case - which this case? Given that the question explicates binary tree is full (each node has 2 child nodes or none) (a commendable diligence), this tries to answer a different question.
Click the link 'complete binary tree' so you can see which case. If you test those algoritms, they will return true, they shouldn't do that cause is not a full tree but a complete tree.
This answer's code checks whether a tree is perfect, which is a different notion. All perfect trees are full, but not vice versa.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.