Question: Please help with this JAVA c ode. Thank you! Complete the implementation of LinkedBinaryTree. Speci cally, implement these methods: get- RootElement(), getRootNode(), getLeft(), getRight(), size(),
Please help with this JAVA code. Thank you!
Complete the implementation of LinkedBinaryTree. Speci cally, implement these methods: get- RootElement(), getRootNode(), getLeft(), getRight(), size(), getHeight(), height(), contains(), toString(), and iteratorPreOrder(). Review the comments in LinkedBinaryTree and BinaryTreeADT for imple- mentation requirements. [12 points]
import java.util.*;
/**
* LinkedBinaryTree implements the BinaryTreeADT interface
*
* @author Lewis and Chase
* @version 4.0
*/
public class LinkedBinaryTree
{
protected BinaryTreeNode
protected int modCount;
/**
* Creates an empty binary tree.
*/
public LinkedBinaryTree()
{
root = null;
}
/**
* Creates a binary tree with the specified element as its root.
*
* @param element the element that will become the root of the binary tree
*/
public LinkedBinaryTree(T element)
{
root = new BinaryTreeNode<>(element);
}
/**
* Creates a binary tree with the specified element as its root and the
* given trees as its left child and right child
*
* @param element the element that will become the root of the binary tree
* @param left the left subtree of this tree
* @param right the right subtree of this tree
*/
public LinkedBinaryTree(T element, LinkedBinaryTree
LinkedBinaryTree
{
root = new BinaryTreeNode<>(element);
root.setLeft(left.root);
root.setRight(right.root);
}
/**
* Returns a reference to the element at the root
*
* @return a reference to the specified target
* @throws EmptyCollectionException if the tree is empty
*/
@Override
public T getRootElement() throws EmptyCollectionException
{
// TODO: Implement this.
}
/**
* Returns a reference to the node at the root
*
* @return a reference to the specified node
* @throws EmptyCollectionException if the tree is empty
*/
protected BinaryTreeNode
{
// TODO: Implement this.
}
/**
* Returns the left subtree of the root of this tree.
*
* @return a link to the left subtree fo the tree
*/
public LinkedBinaryTree
{
// TODO: Implement this.
}
/**
* Returns the right subtree of the root of this tree.
*
* @return a link to the right subtree of the tree
*/
public LinkedBinaryTree
{
// TODO: Implement this.
}
/**
* Returns true if this binary tree is empty and false otherwise.
*
* @return true if this binary tree is empty, false otherwise
*/
@Override
public boolean isEmpty()
{
return (root == null);
}
/**
* Returns the integer size of this tree.
*
* @return the integer size of the tree
*/
@Override
public int size()
{
// TODO: Implement this.
}
/**
* Returns the height of this tree.
*
* @return the height of the tree
*/
public int getHeight()
{
// TODO: Implement this.
}
/**
* Returns the height of the specified node.
*
* @param node the node from which to calculate the height
* @return the height of the tree
*/
private int height(BinaryTreeNode
{
// TODO: Implement this.
}
/**
* Returns true if this tree contains an element that matches the
* specified target element and false otherwise.
*
* @param targetElement the element being sought in this tree
* @return true if the element in is this tree, false otherwise
*/
@Override
public boolean contains(T targetElement)
{
// TODO: Implement this.
}
/**
* Returns a reference to the specified target element if it is
* found in this binary tree. Throws a ElementNotFoundException if
* the specified target element is not found in the binary tree.
*
* @param targetElement the element being sought in this tree
* @return a reference to the specified target
* @throws ElementNotFoundException if the element is not in the tree
*/
public T find(T targetElement) throws ElementNotFoundException
{
BinaryTreeNode
if (current == null)
throw new ElementNotFoundException("LinkedBinaryTree");
return (current.getElement());
}
/**
* Returns a reference to the specified target element if it is
* found in this binary tree.
*
* @param targetElement the element being sought in this tree
* @param next the element to begin searching from
*/
private BinaryTreeNode
BinaryTreeNode
{
if (next == null)
return null;
if (next.getElement().equals(targetElement))
return next;
BinaryTreeNode
if (temp == null)
temp = findNode(targetElement, next.getRight());
return temp;
}
/**
* Returns a string representation of this binary tree showing
* the nodes in an inorder fashion. Each element will be
* separated by a space.
*
* @return a string representation of this binary tree
*/
@Override
public String toString()
{
// TODO: Implement this.
}
/**
* Returns an iterator over the elements in this tree using the
* iteratorInOrder method
*
* @return an in order iterator over this binary tree
*/
@Override
public Iterator
{
return iteratorInOrder();
}
/**
* Performs an inorder traversal on this binary tree by calling an
* overloaded, recursive inorder method that starts with
* the root.
*
* @return an in order iterator over this binary tree
*/
@Override
public Iterator
{
ArrayUnorderedList
inOrder(root, tempList);
return new TreeIterator(tempList.iterator());
}
/**
* Performs a recursive inorder traversal.
*
* @param node the node to be used as the root for this traversal
* @param tempList the temporary list for use in this traversal
*/
protected void inOrder(BinaryTreeNode
ArrayUnorderedList
{
if (node != null)
{
inOrder(node.getLeft(), tempList);
tempList.addToRear(node.getElement());
inOrder(node.getRight(), tempList);
}
}
/**
* Performs an preorder traversal on this binary tree by calling
* an overloaded, recursive preorder method that starts with
* the root.
*
* @return a pre order iterator over this tree
*/
@Override
public Iterator
{
//TODO: Implement this.
}
/**
* 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
*/
protected void preOrder(BinaryTreeNode
ArrayUnorderedList
{
//TODO: Implement this.
}
/**
* Performs an postorder traversal on this binary tree by calling
* an overloaded, recursive postorder method that starts
* with the root.
*
* @return a post order iterator over this tree
*/
@Override
public Iterator
{
throw new UnsupportedOperationException("preOrder");
}
/**
* 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
*/
protected void postOrder(BinaryTreeNode
ArrayUnorderedList
{
//Not required.
}
/**
* Performs a levelorder traversal on this binary tree, using a
* templist.
*
* @return a levelorder iterator over this binary tree
*/
@Override
public Iterator
{
ArrayUnorderedList
ArrayUnorderedList
BinaryTreeNode
nodes.addToRear(root);
while (!nodes.isEmpty())
{
current = nodes.removeFirst();
if (current != null)
{
tempList.addToRear(current.getElement());
if (current.getLeft() != null)
nodes.addToRear(current.getLeft());
if (current.getRight() != null)
nodes.addToRear(current.getRight());
}
else
tempList.addToRear(null);
}
return new TreeIterator(tempList.iterator());
}
/**
* Inner class to represent an iterator over the elements of this tree
*/
private class TreeIterator implements Iterator
{
private int expectedModCount;
private Iterator
/**
* Sets up this iterator using the specified iterator.
*
* @param iter the list iterator created by a tree traversal
*/
public TreeIterator(Iterator
{
this.iter = iter;
expectedModCount = modCount;
}
/**
* Returns true if this iterator has at least one more element
* to deliver in the iteration.
*
* @return true if this iterator has at least one more element to deliver
* in the iteration
* @throws ConcurrentModificationException if the collection has changed
* while the iterator is in use
*/
@Override
public boolean hasNext() throws ConcurrentModificationException
{
if (!(modCount == expectedModCount))
throw new ConcurrentModificationException();
return (iter.hasNext());
}
/**
* Returns the next element in the iteration. If there are no
* more elements in this iteration, a NoSuchElementException is
* thrown.
*
* @return the next element in the iteration
* @throws NoSuchElementException if the iterator is empty
*/
@Override
public T next() throws NoSuchElementException
{
if (hasNext())
return (iter.next());
else
throw new NoSuchElementException();
}
/**
* The remove operation is not supported.
*
* @throws UnsupportedOperationException if the remove operation is called
*/
@Override
public void remove()
{
throw new UnsupportedOperationException();
}
}
}
Step by Step Solution
There are 3 Steps involved in it
Get step-by-step solutions from verified subject matter experts
Study Help