Question & Answer: BinaryTreeMainProgram.java: public class BinaryTreeMainProgram { public static void main(String[] args) {…..

JAVA PLZ

BinaryTreeMainProgram.java:

public class BinaryTreeMainProgram
{
public static void main(String[] args)
{

MyBinaryTree<Integer> myTree = new MyBinaryTree<Integer>();
myTree.add(12);
myTree.add(10);
myTree.add(5);
myTree.add(9);
myTree.add(11);
myTree.add(3);
myTree.add(12);
myTree.add(13);
myTree.add(14);
myTree.add(15);

System.out.print(“The tree contains : “);
System.out.println(myTree) ;

System.out.println();
System.out.println(“The tree looks like : “);
myTree.printSideways();
// New Code Part 1
System.out.println(“******* New Code Part 1 *************”);
System.out.print(“Does the tree contian 9? : “);
System.out.println(myTree.contains(9) );

System.out.print(“Does the tree contian 20? : “);
System.out.println(myTree.contains(20) );

// New Code Part 2
System.out.println(“******* New Code Part 2 *************”);
System.out.print(“The minimum value is ? : “);
System.out.println(myTree.getMin() );

// New Code Part 3
System.out.println(“******* New Code Part 3 *************”);
System.out.print(“Removing : “);
myTree.remove(13);
System.out.println(myTree);
System.out.println(“The tree looks like : “);
myTree.printSideways();

// New Code Part 4
System.out.println(“******* New Code Part 4 *************”);
System.out.print(“The size of the tree is : ” + myTree.size() );

}
}

MyBinaryTree.java:

import java.util.NoSuchElementException;

/****************************************************
* Main Class MyBinaryTree
****************************************************/

public class MyBinaryTree<E extends Comparable<E> >
{

/****************************************************
* Helper Class TreeNode
* Note that this is a class inside the tree
****************************************************/
private class TreeNode<E>
{
public E payload;
public TreeNode<E> left;
public TreeNode<E> right;

public TreeNode (E data)
{
payload = data;
}
}

// Root of the Main tree
private TreeNode<E> root;

/************************************
* Constructor (Default)
************************************/

public MyBinaryTree()
{
root = null;
}

/*****************************************************
* toString Method (starter method)
*****************************************************/

public String toString()
{
if (root == null)
{
return “”;
}

return toString(root);
}

/*****************************************************
* toString Method (recursive method)
*****************************************************/
private String toString(TreeNode<E> tempRoot)
{
if (tempRoot == null) return “”;

return toString(tempRoot.left) + ” ”
+ tempRoot.payload.toString() + ” ”
+ toString(tempRoot.right);

}
/*****************************************************
* printSideways Method (starter method)
***************************************************/
public void printSideways()
{
if (root == null)
{
System.out.println(“Null Tree”);
return;
}
printSideways(root,””);
}
/*****************************************************
* printSideways Method (recursive method)
***************************************************/

private void printSideways(TreeNode<E> tempRoot, String indent)
{
if (tempRoot == null) return;
printSideways(tempRoot.right,” “+indent);
System.out.println(indent + tempRoot.payload.toString() );
printSideways(tempRoot.left,” “+indent);
}

/*****************************************************
* add Method (starter method)
***************************************************/
public void add(E data)
{
root = add(root, data);
}

/*****************************************************
* printSideways Method (recursive method)
***************************************************/

private TreeNode<E> add(TreeNode<E> tempRoot, E data)
{
if (tempRoot == null)
{
TreeNode<E> temp = new TreeNode<E>(data);
return temp;
}

if (tempRoot.payload.compareTo(data) > 0)
{
tempRoot.left = add(tempRoot.left,data);
}
if (tempRoot.payload.compareTo(data) < 0)
{
tempRoot.right = add(tempRoot.right,data);
}
return tempRoot;
}
/*****************************************************
* contains Method (starter method)
***************************************************/
public boolean contains(E lookFor)
{
// Need to implement this.
System.err.println(“NOT IMPLEMENTED”);
return false;
}

/*****************************************************
* contains Method (recursive method)
***************************************************/

public boolean contains(E lookFor, TreeNode<E> temproot)
{
// need this to help with above
return false;
}

/*****************************************************
* getMin Method (starter method)
***************************************************/
public E getMin()
{
// Need to implement this.
System.err.println(“NOT IMPLEMENTED”);
return null;
}

/*****************************************************
* remove Method (recursive method)
***************************************************/

public E getMin(TreeNode<E> temproot)
{
// need this to help with above
return null;
}

/*****************************************************
* remove Method (starter method)
***************************************************/
public void remove(E lookFor)
{
// Need to implement this.
System.err.println(“NOT IMPLEMENTED”);
}

/*****************************************************
* remove Method (recursive method)
***************************************************/

public void remove(E lookFor, TreeNode<E> temproot)
{
// need this to help with above
}

/*****************************************************
* size Method (starter method)
***************************************************/
public int size()
{
// Need to implement this.
System.err.println(“NOT IMPLEMENTED”);
return 0;
}

/*****************************************************
* size Method (recursive method)
***************************************************/

public int size(TreeNode<E> temproot)
{
// need this to help with above
return 0;
}

}