Question

Please help me with me. I did the first part to write the operations but in the driver its shows me errors, can't fix it. Help me.
Need help with this to run the application.
/**
 * BinaryTreeNode represents a node in a binary tree with a left and 
 * right child.
 * 
 * @author Java Foundations
 * @version 4.0
 */
public class BinaryTreeNode
{
 protected T element;
 protected BinaryTreeNode left, right;

 /**
  * Creates a new tree node with the specified data.
  */
 public BinaryTreeNode(T obj) 
 {
  // students complete this method
 }

 /**
  * Returns the number of non-null children of this node.
  */
 public int numChildren() 
 {
  // students complete this method
   return -1;
 }

 /**
  * Return the element at this node.
  */
 public T getElement() 
 {
  // students complete this method
   T temp = null;
   return temp;
 }

 /**
  * Return the right child of this node.
  */
 public BinaryTreeNode getRight() 
 {
  // students complete this method
   BinaryTreeNode temp = null;
   return temp;
 }

 /**
  * Sets the right child of this node.
  */
 public void setRight(BinaryTreeNode node) 
 {
  // students complete this method
 }

 /**
  * Return the left child of this node.
  */
 public BinaryTreeNode getLeft() 
 {
  // students complete this method
   BinaryTreeNode temp = null;
   return temp;
 }

 /**
  * Sets the left child of this node.
  */
 public void setLeft(BinaryTreeNode node) 
 {
  // students complete this method
 }
 
 
}

/**
 * Auto Generated Java Class.
 */
public class TestBinaryTreeNode {
  
  public static void main(String[] args)
  {
   
    // create the tree in Figure 1
  
    
    System.out.println("Preorder: ");
    //preOrder(root);
    System.out.println();
    
    System.out.println("Inorder: ");
    //inOrder(root);
    System.out.println();
  
    System.out.println("Postorder: ");
    //postOrder(root);
    System.out.println();
    
    }



 /**
  * Performs a recursive inorder traversal.
  */
public static void inOrder(BinaryTreeNode node) 
 {
  // students complete this method
}

 /**
  * Performs a recursive preorder traversal.
  *
  * @param node the node to be used as the root for this traversal
  * @param tempList the temporary list for use in this traversal
  */
public static void preOrder(BinaryTreeNode node) 
 {
  // students complete this method
}

 /**
  * Performs a recursive postorder traversal.
  *
  * @param node the node to be used as the root for this traversal
  * @param tempList the temporary list for use in this traversal
  */
public static void postOrder(BinaryTreeNode node) 
 {
  // students complete this method
}

}

Answer 1

Please find the solution below:

I have created code for both the class, as input tree was not provided simulation is not possible. Please use this code, it would generate the appropriate output.

I have mentioned details in comments.

BinaryTreeNode.java

//added generic operator to full fill the requirement
public class BinaryTreeNode<T> {
    protected T element;
    protected BinaryTreeNode<T> left, right;

    /**
     * Creates a new tree node with the specified data.
     */
    public BinaryTreeNode(T obj)
    {
        // students complete this method
        //intialize value and set left and right to null
        this.element = obj;
        this.left = null;
        this.right = null;
    }

    /**
     * Returns the number of non-null children of this node.
     */
    public int numChildren()
    {
        // students complete this method
        //intitalize the children with 0 and then call the method on left and right child
        int childern = 0;
        if(this.left!=null)
            childern = 1 + left.numChildren();
        if(this.right!=null)
            childern = 1 + right.numChildren();
        return childern;
    }

    /**
     * Return the element at this node.
     */
    public T getElement()
    {
        // students complete this method
        return this.element;
    }

    /**
     * Return the right child of this node.
     */
    public BinaryTreeNode<T> getRight()
    {
        // students complete this method
        return this.right;
    }

    /**
     * Sets the right child of this node.
     */
    public void setRight(BinaryTreeNode<T> node)
    {
        // students complete this method
        this.right = node;
    }

    /**
     * Return the left child of this node.
     */
    public BinaryTreeNode<T> getLeft()
    {
        // students complete this method
        return this.left;
    }

    /**
     * Sets the left child of this node.
     */
    public void setLeft(BinaryTreeNode<T> node)
    {
        // students complete this method
        this.left = node;
    }

}

TestBinaryTreeNode.java

package com.company;

public class TestBinaryTreeNode {

    public static void main(String[] args)
    {

        // create the tree in Figure 1
        BinaryTreeNode<Integer> root;
        BinaryTreeNode<Integer> node_4 = new BinaryTreeNode<>(4);
        BinaryTreeNode<Integer> node_2 = new BinaryTreeNode<>(2);
        BinaryTreeNode<Integer> node_7 = new BinaryTreeNode<>(7);
        BinaryTreeNode<Integer> node_1 = new BinaryTreeNode<>(1);
        BinaryTreeNode<Integer> node_3 = new BinaryTreeNode<>(3);
        BinaryTreeNode<Integer> node_6 = new BinaryTreeNode<>(6);
        BinaryTreeNode<Integer> node_9 = new BinaryTreeNode<>(9);
        BinaryTreeNode<Integer> node_8 = new BinaryTreeNode<>(8);
        BinaryTreeNode<Integer> node_10 = new BinaryTreeNode<>(10);

        root = node_4;
        root.setLeft(node_2);
        root.setRight(node_7);

        node_2.setLeft(node_1);
        node_2.setRight(node_3);

        node_7.setLeft(node_6);
        node_7.setRight(node_9);

        node_9.setLeft(node_8);
        node_9.setRight(node_10);


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

        System.out.println("Inorder: ");
        inOrder(root);
        System.out.println();

        System.out.println("Postorder: ");
        postOrder(root);
        System.out.println();

    }
    /**
     * Performs a recursive inorder traversal.
     */
    public static void inOrder(BinaryTreeNode node)
    {
        // students complete this method
        if(node==null)
            return;

        //follow the sequence left.data,root.data,right.data
        inOrder(node.getLeft());
        System.out.print(node.getElement() + " ");
        inOrder(node.getRight());
    }

    /**
     * Performs a recursive preorder traversal.
     *
     * @param node the node to be used as the root for this traversal
     * @param //tempList the temporary list for use in this traversal
     */
    public static void preOrder(BinaryTreeNode node)
    {
        // students complete this method
        if(node==null)
            return;
        //follow the sequence root.data,left.data,right.data
        System.out.print(node.getElement() + " ");
        preOrder(node.getLeft());
        preOrder(node.getRight());
    }

    /**
     * Performs a recursive postorder traversal.
     *
     * @param node the node to be used as the root for this traversal
     * @param //tempList the temporary list for use in this traversal
     */
    public static void postOrder(BinaryTreeNode node)
    {
        // students complete this method
        if(node == null)
            return;
        //follow the sequence left.data,right.data,root.data
        postOrder(node.getLeft());
        postOrder(node.getRight());
        System.out.print(node.getElement() + " ");
    }
}

Output: