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

JAVA PLZ

In the class over the last couple of days, have talked about how to build a binary search tree. We dont have time to write an entire one, but we can take one that works and add some functionality to it. The starter Files. BinaryTreeMainProgram,java My Binary Tree java This is a functioning Binary Tree, but we are missing a couple of important functions. Your job is to implement them. The missing functions are: contains value o This function should search the tree to determine if the value is or is not present. It should return a boolean value. get Min o This should return the smallest value in the tree. remove(value) o This should remove a value from the tree and move the tree as necessary Size o This should find the number of elements in the tree. All functions should be recursive and work correctly. You are welcome to look at the other methods and see how they are implemented to help you out.

Don't use plagiarized sources. Get Your Custom Essay on
BinaryTreeMainProgram.java: public class BinaryTreeMainProgram { public static void main(String[] args) {…
Get an essay WRITTEN FOR YOU, Plagiarism free, and by an EXPERT!
Order Essay

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;
}

}

Show transcribed image text

Expert Answer

 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.

return contains(lookFor,root);

}

/*****************************************************

   * contains Method (recursive method)

   ***************************************************/

public boolean contains(E lookFor, TreeNode<E> temproot)

{

// need this to help with above

      if (temproot != null) {

           if (temproot.payload.equals(lookFor)) {

               return true;

           } else

               return contains(lookFor,temproot.left) || contains(lookFor,temproot.right);

          

          

          

          

       }

      return false;

  

  

}

/*****************************************************

   * getMin Method (starter method)

   ***************************************************/

public E getMin()

{

// Need to implement this.

  

return getMin(root);

}

/*****************************************************

   * remove Method (recursive method)

   ***************************************************/

@SuppressWarnings(“unchecked”)

public E getMin(TreeNode<E> temproot)

{

      if (null == temproot)

           return (E)new Integer(Integer.MAX_VALUE);

       E data = temproot.payload;

       E left = getMin(temproot.left);

       E right = getMin(temproot.right);

      

      

       Integer i = new Integer(Math.min((int) data, Math.min((int) left, (int) right)));

       return (E) i;

}

/*****************************************************

* 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.

return size(root);

}

/*****************************************************

* size Method (recursive method)

***************************************************/

public int size(TreeNode<E> temproot)

{

// need this to help with above

      if (temproot == null)

           return 0;

       else

           return 1 + size(temproot.left) + size(temproot.right);

}

}

======================================================
I have implemented how much I could do in given time

Top Grade Homework
Order NOW For a 10% Discount!
Pages (550 words)
Approximate price: -

Why Work with Us

Top Quality and Well-Researched Papers

We always make sure that writers follow all your instructions precisely. You can choose your academic level: high school, college/university or professional, and we will assign a writer who has a respective degree.

Professional and Experienced Academic Writers

We have a team of professional writers with experience in academic and business writing. Many are native speakers and able to perform any task for which you need help.

Free Unlimited Revisions

If you think we missed something, send your order for a free revision. You have 10 days to submit the order for review after you have received the final document. You can do this yourself after logging into your personal account or by contacting our support.

Prompt Delivery and 100% Money-Back-Guarantee

All papers are always delivered on time. In case we need more time to master your paper, we may contact you regarding the deadline extension. In case you cannot provide us with more time, a 100% refund is guaranteed.

Original & Confidential

We use several writing tools checks to ensure that all documents you receive are free from plagiarism. Our editors carefully review all quotations in the text. We also promise maximum confidentiality in all of our services.

24/7 Customer Support

Our support agents are available 24 hours a day 7 days a week and committed to providing you with the best customer experience. Get in touch whenever you need any assistance.

Try it now!

Calculate the price of your order

Total price:
$0.00

How it works?

Follow these simple steps to get your paper done

Place your order

Fill in the order form and provide all details of your assignment.

Proceed with the payment

Choose the payment system that suits you most.

Receive the final file

Once your paper is ready, we will email it to you.

Our Services

No need to work on your paper at night. Sleep tight, we will cover your back. We offer all kinds of writing services.

Essays

Essay Writing Service

No matter what kind of academic paper you need and how urgent you need it, you are welcome to choose your academic level and the type of your paper at an affordable price. We take care of all your paper needs and give a 24/7 customer care support system.

Admissions

Admission Essays & Business Writing Help

An admission essay is an essay or other written statement by a candidate, often a potential student enrolling in a college, university, or graduate school. You can be rest assurred that through our service we will write the best admission essay for you.

Reviews

Editing Support

Our academic writers and editors make the necessary changes to your paper so that it is polished. We also format your document by correctly quoting the sources and creating reference lists in the formats APA, Harvard, MLA, Chicago / Turabian.

Reviews

Revision Support

If you think your paper could be improved, you can request a review. In this case, your paper will be checked by the writer or assigned to an editor. You can use this option as many times as you see fit. This is free because we want you to be completely satisfied with the service offered.

× Contact Live Agents