Question

i need help to modify this Tree class to include a method leavesCount that returns the number of leaves in a binary tree. (NOTE: Complete leavesCount and leavesCountHelper methods in the Tree class). I already have the test class. java

class TreeNode< T extends Comparable< T > >

{

TreeNode< T > leftNode;

T data;

TreeNode< T > rightNode;

public TreeNode( T nodeData )

{ data = nodeData;

leftNode = rightNode = null; }

public void insert( T insertValue ) {

if ( insertValue.compareTo( data ) < 0 )

{

if ( leftNode == null )

leftNode = new TreeNode< T >( insertValue );

else

leftNode.insert( insertValue ); }

else if ( insertValue.compareTo( data ) > 0 )

{

if ( rightNode == null )

rightNode = new TreeNode< T >( insertValue );

else

rightNode.insert( insertValue );

}

}

}

public class Tree< T extends Comparable< T > >

{

private TreeNode< T > root;

public Tree()

{

root = null;

}

public void insertNode( T insertValue )

{

if ( root == null )

root = new TreeNode< T >( insertValue );

else

root.insert( insertValue );

}

public void preorderTraversal()

{

preorderHelper( root );

}

private void preorderHelper( TreeNode< T > node )

{

if ( node == null )

return;

System.out.printf( "%s ", node.data );

preorderHelper( node.leftNode );

preorderHelper( node.rightNode );

}

public void inorderTraversal()

{

inorderHelper( root );

}

private void inorderHelper( TreeNode< T > node )

{

if ( node == null )

return;

inorderHelper( node.leftNode );

System.out.printf( "%s ", node.data );

inorderHelper( node.rightNode );

}

public void postorderTraversal()

{

postorderHelper( root );

}

private void postorderHelper( TreeNode< T > node )

{

if ( node == null )

return;

postorderHelper( node.leftNode );

postorderHelper( node.rightNode );

System.out.printf( "%s ", node.data ); // output node data

}

public int nodeCount()

{

return nodeCountHelper( root );

}

private int nodeCountHelper(TreeNode< T > node)

{

if (node == null)

return 0;

else

return 1 + nodeCountHelper(node.leftNode) + nodeCountHelper(node.rightNode);

}

public int leavesCount()

{

//write code

}

private int leavesCountHelper(TreeNode< T > node)

{

//write code

}

} // end class Tree

Answer 1

I've added a main method to test count leaves method whose input is below

Input

Output

Code with comments

public class Test {

    static class TreeNode<T extends Comparable<T>>{

        TreeNode<T> leftNode;

        T data;

        TreeNode<T> rightNode;

        public TreeNode(T nodeData)

        {

            data = nodeData;

            leftNode = rightNode = null;

        }

        public void insert(T insertValue) {

            if (insertValue.compareTo(data) < 0)

            {

                if (leftNode == null)

                    leftNode = new TreeNode<T>(insertValue);

                else

                    leftNode.insert(insertValue);

            }

            else if (insertValue.compareTo(data) > 0)

            {

                if (rightNode == null)

                    rightNode = new TreeNode<T>(insertValue);

                else

                    rightNode.insert(insertValue);

            }

        }

    }

    static public class Tree<T extends Comparable<T>>

    {

        private TreeNode<T> root;

        public Tree()

        {

            root = null;

        }

        public void insertNode(T insertValue)

        {

            if (root == null)

                root = new TreeNode<T>(insertValue);

            else

                root.insert(insertValue);

        }

        public void preorderTraversal()

        {

            preorderHelper(root);

        }

        private void preorderHelper(TreeNode<T> node)

        {

            if (node == null)

                return;

            System.out.printf("%s ", node.data);

            preorderHelper(node.leftNode);

            preorderHelper(node.rightNode);

        }

        public void inorderTraversal()

        {

            inorderHelper(root);

        }

        private void inorderHelper(TreeNode<T> node)

        {

            if (node == null)

                return;

            inorderHelper(node.leftNode);

            System.out.printf("%s ", node.data);

            inorderHelper(node.rightNode);

        }

        public void postorderTraversal()

        {

            postorderHelper(root);

        }

        private void postorderHelper(TreeNode<T> node)

        {

            if (node == null)

                return;

            postorderHelper(node.leftNode);

            postorderHelper(node.rightNode);

            System.out.printf("%s ", node.data); // output node data

        }

        public int nodeCount()

        {

            return nodeCountHelper(root);

        }

        private int nodeCountHelper(TreeNode<T> node)

        {

            if (node == null)

                return 0;

            else

                return 1 + nodeCountHelper(node.leftNode) + nodeCountHelper(node.rightNode);

        }

        public int leavesCount()

        {

            return leavesCountHelper(root);

        }

        private int leavesCountHelper(TreeNode<T> node)

        {

            if(node==null)  //node is null

                return 0;

            if(node.leftNode==null && node.rightNode==null) //node is leaf

                return 1;

            return leavesCountHelper((node.leftNode))+leavesCountHelper((node.rightNode));  //sum of leaf nodes in left and right subtree

        }

    } // end class Tree

    public static void main(String[] args) {

        Tree<Integer>tree=new Tree<>();

        tree.insertNode(4);

        tree.insertNode(3);

        tree.insertNode(6);

        tree.insertNode(5);

        tree.insertNode(1);

        tree.insertNode(2);

        System.out.println("Preorder:");

        tree.preorderTraversal();

        System.out.println("\nPostorder:");

        tree.postorderTraversal();

        System.out.println("\nInorder:");

        tree.inorderTraversal();

        System.out.println("\nTotal leaf nodes = "+tree.leavesCount());

    }

}

For indentation purpose