Question

Can someone help me in java Net Beans IDE witht the code and java comments. Thanks

Many of these classes will just need to be copied from previous assignments. When you implement the Tree interface you may import the java.util.Iterator class. When you implement the AbstractBinaryTree class you may import the java.util.ArrayList class and the java.util.List class.

In this project you will be doing the following:

Create a NetBeans project named lab07 and ensure it is imported into your SVN.

In this lab assignment you will be implementing the abstract binary tree, the linked binary tree. In completing this assignment, you must include and use the interfaces and classes for the abstract tree, abstract binary tree and the linked binary tree ADTs presented in the textbook.

Implement the LinkedBinaryTree class described in code fragments 8.8 to 8.11 in the textbook. Also implement all classes that the LinkedBinaryTree class depends on. Be sure to review code fragments 8.1 to 8.28 to make sure that you have include all of the necessary code. In some cases the needed code may not appear in a formal code fragment but is implied in the text.

Many of these classes will just need to be copied from previous assignments. When you implement the Tree interface you may import the java.util.Iterator class. When you implement the AbstractBinaryTree class you may import the java.util.ArrayList class and the java.util.List class.

Once you have successfully implement the LinkedBinaryTree class, create a client class, TreeClient, that does the following:

• Manually creates an instance of a binary expression tree that represents the following expression:

• (((5+2)*(2-1))/((2+9)+((7-2)-1))*8)

• Do this by using methods such as addRoot, addLeft, addRight, set, and attach.

• The element should be of type String

• Note that you are manually building this specific expression tree, the pseudo code might look something like:

• Create a LinkedBinaryTree

• Add “*” as the root to the tree

• Add “/” as the left child to the tree

• Add “8” the right child to the tree

• Add a left child to the root’s left child

• Add a right child to the root’s left child

• etc.

You may want to consider if it would be easier to build the tree in a top down fashion or in a bottom up fashion.

Once you have created the expression tree have your client print out the following:

• The String that represents the expression, (i.e. (((5+2)*(2-1))/((2+9)+((7-2)-1))*8)

• The preorder traversal of the tree

• The inOrder traversal of the tree

• The postOrder traversal of the tree

• The breathFirst traversal of the tree

• The preOrderIndent traversal of the tree

• The parenthesized representation of the tree
  

Answer 1

Working code implemented in Java and appropriate comments provided for better understanding:

Here I am attaching code for these files:

Source code for Client.java:

import java.util.ArrayList;

public class Client {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
System.out.println("Begin Lab7");
System.out.println("Creating the following equation in a "
+ "linkedBinaryTree: (((5+2)*(2-1)/(2+9)+((7-2)-1))*8) ");
  
//creating bottom branch
LinkedBinaryTree LBT1 = new LinkedBinaryTree<>();
LBT1.addRoot("+");
LBT1.addLeft(LBT1.root, "5");
LBT1.addRight(LBT1.root, "2");
  
LinkedBinaryTree LBT2 = new LinkedBinaryTree<>();
LBT2.addRoot("-");
LBT2.addLeft(LBT2.root, "2");
LBT2.addRight(LBT2.root, "1");
  
LinkedBinaryTree LBT3 = new LinkedBinaryTree<>();
LBT3.addRoot("*");
LBT3.attach(LBT3.root, LBT1, LBT2);
  
LinkedBinaryTree LBT4 = new LinkedBinaryTree<>();
LBT4.addRoot("+");
LBT4.addLeft(LBT4.root, "2");
LBT4.addRight(LBT4.root, "9");
  
LinkedBinaryTree LBT5 = new LinkedBinaryTree<>();
LBT5.addRoot("/");
LBT5.attach(LBT5.root, LBT3, LBT4);
  
LinkedBinaryTree LBT6 = new LinkedBinaryTree<>();
LBT6.addRoot("-");
LBT6.addLeft(LBT6.root, "7");
LBT6.addRight(LBT6.root, "2");
  
LinkedBinaryTree LBT8 = new LinkedBinaryTree<>();
LBT8.addRoot("1");
  
LinkedBinaryTree LBT7 = new LinkedBinaryTree<>();
LBT7.addRoot("-");
LBT7.attach(LBT7.root, LBT7, LBT8);
  
LinkedBinaryTree LBT9 = new LinkedBinaryTree<>();
LBT9.addRoot("+");
LBT9.attach(LBT9.root, LBT5, LBT7);
  
LinkedBinaryTree LBT11 = new LinkedBinaryTree<>();
LBT11.addRoot("8");
  
LinkedBinaryTree LBT10 = new LinkedBinaryTree<>();
LBT10.addRoot("*");
LBT10.attach(LBT10.root, LBT9, LBT11);
  
System.out.println("\n\nA The preoder traversal of the tree");
for(Position p : LBT10.preOrder())
System.out.print(p.getElement());
  
System.out.println("\n\n The inOrder traversal of the tree");
for(Position p : LBT10.inOrder())
System.out.print(p.getElement());
  
System.out.println("\n\nThe postOrder traversal of the tree");
for(Position p : LBT10.postOrder())
System.out.print(p.getElement());
  
System.out.println("\n\nThe breathFirst traversal of the tree");
for(Position p : LBT10.breadthfirst())
System.out.print(p.getElement());
  
System.out.println("\n\nThe preOrderIndent traversal of the tree");
printPreOrderIndent(LBT10, LBT10.root, 0);
  
System.out.println("\n\nA The Parenthesized representation of the tree");
parenthesize(LBT10, LBT10.root);
  
System.out.println("\n\nEnd Lab7");
}
  
public static void printPreOrderLabeled(TreeInterface T, Position p, ArrayList path){
int d = path.size();
System.out.print(spaces(2*d));
for(int i= 0; i System.out.println(p.getElement());
path.add(1);
  
for(Position c : T.children(p)){
printPreOrderLabeled(T, c, path);
path.set(d, 1 + path.get(d));
}
path.remove(d);
}
  
private static String spaces(int t){
String temp = "";
for(int c = 0; c temp +=(" ");
return temp;
}
  
public static int diskSpace(TreeInterface T, Position p){
int subtotal = p.getElement();
for(Position c : T.children(p))
subtotal += diskSpace(T, c);
return subtotal;
}
  
public static void parenthesize(TreeInterface T, Position p){
System.out.print(p.getElement());
if(T.isInternal(p)){
boolean firstTime=true;
for(Position c : T.children(p)){
System.out.print((firstTime ? " (" : ", "));
firstTime = false;
parenthesize(T, c);
}
System.out.print(")");
}
}
  
public static void printPreOrderIndent(TreeInterface T, Position p, int d){
System.out.println(spaces(2 * d) + p.getElement());
for(Position c : T.children(p))
printPreOrderIndent(T, c, d+1);
}
}

Source code for AbstractBinaryTree.java

import java.util.Iterator;
import java.util.ArrayList;
import java.util.List;

public abstract class AbstractBinaryTree extends AbstractTree implements BinaryTreeInterface {
@Override
//Returns the Position of p's sibling(or null if no sibling exists).
public Position sibling(Position p){
Position parent = parent(p);
if(parent == null) return null; //p must be root
if(p==left(parent)) //p is a left child
return right(parent); //(right child might be null)
else //p is a right child
return left(parent); //(left child might be null)
}
@Override
//Returns the number of children of Position p.
public int numChildren(Position p){
int count = 0;
if(left(p) != null)
count++;
if(right(p) != null)
count++;
return count;
}
@Override
//Returns an iterable collection of the Positions representing p's children.
public Iterable> children(Position p){
List> snapshot = new ArrayList<>(2); //max capacity of 2
if(left(p) != null)
snapshot.add(left(p));
if(right(p) != null)
snapshot.add(right(p));
return (Iterable>) snapshot;
}

//Adds positions of the subtree rooted at position p to the given snapshot.
private void preorderSubtree(Position p, List> snapshot){
snapshot.add(p);
for (Position c : children(p)){
preorderSubtree(c, snapshot);
}
}
  
//Returns an iterable collection of positions for the tree, reported in preorder.
public Iterable> preOrder(){
List> snapshot = new ArrayList<>();
if(!isEmpty()){
preorderSubtree(root(), snapshot);
}
return (Iterable>) snapshot;
}
  
//Adds positions of the subtree rooted at Position p to the given snapshot.
private void postorderSubtree(Position p, List> snapshot){
for(Position c : children(p))
postorderSubtree(c, snapshot);
snapshot.add(p);
}
  
//Returns an iterable collection of positions of the tree, reported in postorder.
public Iterable> postOrder(){
List> snapshot = new ArrayList<>();
if(!isEmpty())
postorderSubtree(root(), snapshot);
return(Iterable>) snapshot;
}
  
//Returns an iterable colection of positions for the tree in breadth-first order.
public Iterable> breadthfirst(){
List> snapshot = new ArrayList<>();
if(!isEmpty()){
Queue> fringe = new LinkedQueue>();
fringe.enqueue(root());
while(!fringe.isEmpty()){
Position p = fringe.dequeue();
snapshot.add(p);
for(Position c : children(p))
fringe.enqueue(c);
}
}
return snapshot;
}
  
//Adds positions of the subtree rooted at Postion p to the given snapshot.
private void inorderSubtree(Position p, List> snapshot){
if(left(p) != null)
inorderSubtree(left(p), snapshot);
snapshot.add(p);
if(right(p) != null)
inorderSubtree(right(p), snapshot);
}
  
//Returns an iterable collection of positions of the tree, reported in inorder.
public Iterable> inOrder(){
List> snapshot = new ArrayList<>();
if(!isEmpty())
inorderSubtree(root(), snapshot);
return snapshot;
}
  
//Overrides positions to make inorder the default order for binary trees.
@Override
public Iterable> positions(){
return inOrder();
}
}

Source code for AbstractTree.java

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public abstract class AbstractTree implements TreeInterface {
@Override
public boolean isInternal(Position p) { return numChildren(p) > 0;}
@Override
public boolean isExternal(Position p) {return numChildren(p) == 0;}
@Override
public boolean isRoot(Position p) {return p == root();}

  
//Returns the number of levels separating Position p from the root.
public int depth(Position p){
if(isRoot(p))
return 0;
else
return 1 + depth(parent(p));
}
  
//Returns the height of the subtree rooted at Position p.
public int height(Position p){
int h=0; //base case if p is external
for(Position c : children(p))
h = Math.max(h, 1 + height(c));
return h;
}
}

Source code for BinaryTreeInterface.java
//An interface for a binary tree, in which each node has at most two children.
public interface BinaryTreeInterface extends TreeInterface {
  
//returns the position of p's left child (or null if no child exists).
Position left(Position p) throws IllegalArgumentException;
  
//Returns the position of p's right child (or null if no child exists).
Position right(Position p) throws IllegalArgumentException;
//Returns the position of p's sibling (or null if no sibling exists).
Position sibling(Position p) throws IllegalArgumentException;
}

Source code for Iterator.java
public interface Iterator {
boolean hasNext();
E next();
void remove() throws IllegalStateException;
}

Source code for LinkedBinaryTree.java

import java.util.Iterator;

//Concrete implemenatation of a binary tree using a node-based, linked structure.
public class LinkedBinaryTree extends AbstractBinaryTree {
//----------------nested node class---------------------
protected static class Node implements Position{
private E element; //an element stroed at this node
private Node parent; //a reference to the parent node (if any)
private Node left; //a reference to the left child (if any)
private Node right; //a reference to the right child(if any)
//constructs a node with the given element and neighbors.
public Node(E e, Node above, Node leftChild, Node rightChild){
element = e;
parent = above;
left = leftChild;
right = rightChild;
}
//accessor methods
@Override
public E getElement(){ return element;}
public Node getParent(){ return parent;}
public Node getLeft(){ return left;}
public Node getRight(){ return right;}
//update methods
public void setElement(E e){ element = e;}
public void setParent(Node parentNode){parent = parentNode;}
public void setLeft(Node leftChild) { left = leftChild;}
public void setRight(Node rightChild) {right = rightChild;}
}
//------------------end nested node class--------------------
//Factory function to create a new node storing element e.
protected Node createNode(E e, Node parent,
Node left, Node right){
return new Node(e, parent, left, right);
}
//LinkedBinaryTree instance variables
protected Node root = null; //root of the tree
private int size = 0; //number of nodes i the tree
  
//constructor
public LinkedBinaryTree(){} //contructs an empty binary tree
//nonpublic utility
//Validates the position and returns it as a node.
protected Node validate(Position p) throws IllegalArgumentException{
if(!(p instanceof Node))
throw new IllegalArgumentException("Not valid positon type");
Node node = (Node) p; //safe cast
if(node.getParent()==node) //our convention for defunct node
throw new IllegalArgumentException("p is not longer in the tree");
return node;
}
  
//accessor methods (not already implemented in AbstractBinaryTree)
//Returns the number of nodes in the tree.
@Override
public int size(){
return size;
}
  
//returns the root position of the tree (or null if tree is empty).
@Override
public boolean isEmpty(){
return size==0;
}
  
//-----------------------nested ElementIterator class-----------------------
private class ElementIterator implements Iterator{
Iterator> posIterator = positions().iterator();
@Override
public boolean hasNext(){return posIterator.hasNext();}
@Override
public E next(){return posIterator.next().getElement();}
@Override
public void remove(){posIterator.remove();}
}
  
  
//returns an iterator of the elements stored in tree.
@Override
public Iterator iterator(){return new ElementIterator();}
public Iterable> postions(){return preOrder();}
@Override
  
//returns the root position of the tree(null if the is empty).
public Position root(){
return root;
}
  
//Returns the position of p's parent (or null if p is root).
@Override
public Position parent(Position p) throws IllegalArgumentException{
Node node = validate(p);
return node.getParent();
}
  
//Returns the position of p's left child (or null if no child exists).
@Override
public Position left(Position p) throws IllegalArgumentException{
Node node = validate(p);
return node.getLeft();
}
  
//Returns the Position of p's right child (or null if no child exists).
@Override
public Position right(Position p) throws IllegalArgumentException{
Node node = validate(p);
return node.getRight();
}
  
//update methods supported by this class
//Places element e at the root of an empty tree and returns its new Position.
public Position addRoot(E e) throws IllegalStateException{
if(!isEmpty()) throw new IllegalStateException("Tree is not empty");
root = createNode(e, null, null, null);
//parent.setLeft(child);
size++;
return root;
}
  
//Creates a new left child of Position p storing element e; returns its position.
public Position addLeft(Position p, E e) throws IllegalArgumentException{
Node parent = validate(p);
if(parent.getLeft() != null)
throw new IllegalArgumentException("p already has a left child");
Node child = createNode(e, parent, null, null);
parent.setLeft(child);
size++;
return child;
}
  
//Creates a new right child of Position p storing element e; returns its Position.
public Position addRight(Position p, E e) throws IllegalArgumentException{
Node parent = validate(p);
if(parent.getRight() != null)
throw new IllegalArgumentException("p already has a right child");
Node child = createNode(e, parent, null, null);
parent.setRight(child);
size++;
return child;
}
  
//Replaces the element at Position p with e and returns the replaced element.
public E set(Position p, E e) throws IllegalArgumentException{
Node node = validate(p);
E temp = node.getElement();
node.setElement(e);
return temp;
}
  
//Attaches tree t1 and t2 as left and right subtrees of external p.
public void attach(Position p, LinkedBinaryTree t1,
LinkedBinaryTree t2) throws IllegalArgumentException{
Node node = validate(p);
if(isInternal(p)) throw new IllegalArgumentException("p must be a leaf");
size += t1.size() + t2.size();
if(!t1.isEmpty()){ //attach t1 as left subtree of node
t1.root.setParent(node);
node.setLeft(t1.root);
t1.root=null;
t1.size=0;
}
if(!t2.isEmpty()){ //attach t2 as right subtree of node
t2.root.setParent(node);
node.setRight(t2.root);
t2.root = null;
t2.size = 0;
}
}
//Removes the node at Position p and replaces it with its child, if any.
public E remove(Position p) throws IllegalArgumentException{
Node node = validate(p);
if(numChildren(p)==2)
throw new IllegalArgumentException("p has two children");
Node child = (node.getLeft() != null ? node.getLeft() : node.getRight());
if(child != null)
child.setParent(node.getParent()); //child's grandparent becomes its parent
if(node==root)
root=child; //child becomes root
else{
Node parent = node.getParent();
if(node==parent.getLeft())
parent.setLeft(child);
else
parent.setRight(child);
}
size--;
E temp = node.getElement();
node.setElement(null); //help garbage collection
node.setLeft(null);
node.setRight(null);
node.setParent(node); //our convention for defunct node
return temp;
}
}//----------------------------end of LinkedBinaryTree Class------------------

Source code for LinkedQueue.java
public class LinkedQueue implements Queue {
private final SinglyLinkedList list = new SinglyLinkedList<>();//empty list
public LinkedQueue(){}
//new queue relies on initially empty list
@Override
public int size(){return list.size();}
@Override
public boolean isEmpty(){return list.isEmpty();}
@Override
public void enqueue(E element){list.addLast(element);}
@Override
public E first(){return list.first();}
@Override
public E dequeue(){return list.removeFirst();}
  
}

Source code for Position.java
public interface Position {
E getElement() throws IllegalStateException;
}

Source code for Queue.java
public interface Queue {
//Returns the number of elements in queue
int size();
  
//Checks if queue is empty
boolean isEmpty();
  
//Inserts an element at end of the queue
void enqueue(E e);
  
//Returns but does not remove the first element of the queue(null if empty).
E first();
  
//Removes and returns the first element of the queue(null if empty).
E dequeue();
}

Source code for SinglyLinkedList.java
public class SinglyLinkedList {
//--------------------------nested node class--------------------------------
private static class Node {
private E element;
private Node next;
public Node(E e, Node n){
element = e;
next = n;
}
public E getElement(){return element;}
public Node getNext(){return next;}
public void setNext(Node n){next = n;}
}
//----------------------end of nested Node Class----------------------------
  
//Instance variables of SinglyLinkedList
private Node head = null;
private Node tail = null;
private int size = 0;
  
//constructs an initially empty list
public SinglyLinkedList(){}
  
//returns the size of the list
public int size(){
return size;
}
  
//determines if the list is empty
public boolean isEmpty(){return size == 0;}
  
//returns but does not remove first element
public E first(){
if(isEmpty()) {return null;}
return head.getElement();
}
  
//Returns but does not remove the last element
public E last(){
if(isEmpty()){return null;}
return tail.getElement();
}
  
//Adds an element to front of the list
public void addFirst(E e){
head = new Node<>(e, head);
if(size==0)
tail = head;
size++;
}
  
//Adds an element to the end of the list
public void addLast(E e){
Node newest = new Node<>(e, null);
if(isEmpty())
head = newest;
else
tail.setNext(newest);
  
tail = newest;
size++;
}
  
//Returns and removes the first element
public E removeFirst(){
if(isEmpty()) return null;
E answer = head.getElement();
head = head.getNext();
size--;
if(size==0)
tail = null;
return answer;
}
  
//returns a formatted string regarding curent instance of the class
public String toString(){
String result = getClass().getName() + "@ size: " + size;
for(int i = 0; i E temp = removeFirst();
result += " : " + temp;
addLast(temp);
}
return result;
}
}

Source code for TreeInterface.java

import java.util.Iterator;
//An interface for a tree where nodes can have an arbitrary number of children.
public interface TreeInterface extends Iterable {
Position root();
Position parent(Position p) throws IllegalArgumentException;
Iterable> children(Position p)
throws IllegalArgumentException;
int numChildren(Position p) throws IllegalArgumentException;
boolean isInternal(Position p) throws IllegalArgumentException;
boolean isExternal(Position p) throws IllegalArgumentException;
boolean isRoot(Position p) throws IllegalArgumentException;
int size();
boolean isEmpty();
  
@Override
Iterator iterator();
Iterable> positions();
}

Output Screenshots: