I am currently using eclipse to write in java. Here is the previous exercise cod

Question

I am currently using eclipse to write in java.

Here is the previous exercise code that may help:

////////////////////////Main
/**************************************
* Week 6 lab - exercise 1: *
* implementing a binary search tree *
***************************************/

/**
* Class testing the binary search tree.
*/
public class Main
{

public static void main(String[] args)
{
BinarySearchTree bst = new BinarySearchTree();
for (int i = 0; i < 10; i++)
{
int x = (int) (Math.random() * 100);
System.out.print(x + " ");
bst.add(x);
}

System.out.println();
bst.display();
}
}

/////////////////////////////BinarySearchTree
/**************************************
* Week 6 lab - exercise 1: *
* implementing a binary search tree *
***************************************/

/**
* Class implementing a binary search tree.
*/
public class BinarySearchTree
{
/**
* Initializes the bst to empty creating a dummy root node.
*/
public BinarySearchTree()
{
root = new Node(); //dummy node as the root
root.setLeftChild(null);
root.setRightChild(null);
root.setInfo(-1);
}

/**
* Determines whether the bst is empty
*
* @return true if the bst is empty, false otherwise
*/
public boolean isEmpty()
{
return root.getLeftChild() == null;
}

/**
* Prints the bst elements using inorder traversal. This method invokes the
* private method inorderDisplay, passing to it the root of the actual tree.
*/
public void display()
{
inorderDisplay(root.getLeftChild());
System.out.println();
}

/**
* Determines if an item exists in the bst. This method invokes the private
* method search, passing to it the element to be found and the root
* of the actual tree.
*
* @param x element to be found.
* @return true if x is found in the bst, false otherwise.
*/
public boolean contains(int x)
{
return search(x, root.getLeftChild());
}

/**
* Adds the element x to the bst. This method invokes the private method
* insert, passing to it the element to be added to the bst and the root
* of the actual tree.
*
* @param x element to be added to the bst.
*/
public void add(int x)
{
if (root.getLeftChild() == null)
{
Node p = new Node();
p.setNode(x, null, null);
root.setLeftChild(p);
} else
insert(x, root.getLeftChild());
}

/**
* Finds the smallest element in the bst. This method invokes the overloaded
* method getMin, passing to it the root of the tree.
*
* @return the smallest element in the bst.
*/
public int getMin()
{
return getMin(root);
}
  
private Node root; //root of the bst. It's implemented as a dummy node.

/**
* Prints the elements of the subtree whose root is referenced by p. Uses
* inorder traversal.
*
* @param p root of subtree.
*/
private void inorderDisplay(Node p)
{
if (p != null)
{
inorderDisplay(p.getLeftChild());
System.out.print(p.getInfo() + " ");
inorderDisplay(p.getRightChild());
}
}

/**
* Finds if x is inserted in the subtree whose root is referenced by p. The
* search is conducted recursively, using the bst property: keys in the left
* subtree of a node are smaller than or equal to the key in the node, while
* the keys in the right subtree of the node are greater.
*
* @param x element to be found.
* @param p root of subtree.
* @return true if x is found in this subtree, false otherwise.
*/
private boolean search(int x, Node p)
{
if (p == null)
return false;
else if (x == p.getInfo())
return true;
else if (x < p.getInfo())
return search(x, p.getLeftChild());
else
return search(x, p.getRightChild());
}

/**
* Adds x to the subtree referenced by p. The search for the location to
* insert the new node is conducted recursively, using the bst property:
* keys in the left subtree of a node are smaller than or equal to the key
* in the node, while the keys in the right subtree of the node are greater.
*
* @param x element to be added to the subtree.
* @param p root of subtree.
*/
private void insert(int x, Node p)
{
if (x < p.getInfo())
if (p.getLeftChild() == null)
{
Node q = new Node();
q.setNode(x, null, null);
p.setLeftChild(q);
} else
insert(x, p.getLeftChild());
else if (p.getRightChild() == null)
{
Node q = new Node();
q.setNode(x, null, null);
p.setRightChild(q);
} else
insert(x, p.getRightChild());
}

/**
* Recursively finds the smallest element in the subtree referenced by p.
* The method uses this property of BSTs: the smallest value is stored in
* the leftmost node.
*
* @param p root of subtree.
* @return smallest element in the subtree referenced by p.
*/
private int getMin(Node p)
{
if (p.getLeftChild() == null)
return p.getInfo();
else
return getMin(p.getLeftChild());
}
}

//////////////////////////////Node
/**************************************
* Week 6 lab - exercise 1: *
* implementing a binary search tree *
***************************************/

/**
* Binary search tree node.
*/
public class Node
{

private int info; //element stored in this node
private Node left; //link to left child
private Node right; //link to right child

/**
* Initializes this node setting info to 0 and left and right children to
* null.
*/
Node()
{
info = 0;
left = right = null;
}

/**
* Sets this node.
*
* @param x the desired value for this node.
* @param l node reference.
* @param r node reference.
*/
void setNode(int x, Node l, Node r)
{
info = x;
left = l;
right = r;
}

/**
* Returns the value in this node.
*
* @return the value in this node.
*/
int getInfo()
{
return info;
}

/**
* Returns the link to the left child.
*
* @return link to the left child.
*/
Node getLeftChild()
{
return left;
}

/**
* Returns the link to the right child.
*
* @return link to the right child.
*/
Node getRightChild()
{
return right;
}

/**
* Sets the value for this node.
*
* @param x the desired value for this node.
*/
void setInfo(int x)
{
info = x;
}

/**
* Sets the link to the left child.
*
* @param l node reference.
*/
void setLeftChild(Node l)
{
left = l;
}

/**
* Sets the link to the right child.
*
* @param r node reference.
*/
void setRightChild(Node r)
{
right = r;
}
}

Explanation / Answer

Remove public from your BinarySearchTree and Node class

public class Main
{
public static void main(String[] args)
{
BinarySearchTree bst = new BinarySearchTree();
for (int i = 0; i < 10; i++)
{
int x = (int) (Math.random() * 100);
System.out.print(x + " ");
bst.add(x);
}
System.out.println();
bst.display();
}
}

/////////////////////////////BinarySearchTree
/**************************************
* Week 6 lab - exercise 1: *
* implementing a binary search tree *
***************************************/
/**
* Class implementing a binary search tree.
*/
class BinarySearchTree
{
/**
* Initializes the bst to empty creating a dummy root node.
*/
public BinarySearchTree()
{
root = new Node(); //dummy node as the root
root.setLeftChild(null);
root.setRightChild(null);
root.setInfo(-1);
}
/**
* Determines whether the bst is empty
*
* @return true if the bst is empty, false otherwise
*/
public boolean isEmpty()
{
return root.getLeftChild() == null;
}
/**
* Prints the bst elements using inorder traversal. This method invokes the
* private method inorderDisplay, passing to it the root of the actual tree.
*/
public void display()
{
inorderDisplay(root.getLeftChild());
System.out.println();
}
/**
* Determines if an item exists in the bst. This method invokes the private
* method search, passing to it the element to be found and the root
* of the actual tree.
*
* @param x element to be found.
* @return true if x is found in the bst, false otherwise.
*/
public boolean contains(int x)
{
return search(x, root.getLeftChild());
}
/**
* Adds the element x to the bst. This method invokes the private method
* insert, passing to it the element to be added to the bst and the root
* of the actual tree.
*
* @param x element to be added to the bst.
*/
public void add(int x)
{
if (root.getLeftChild() == null)
{
Node p = new Node();
p.setNode(x, null, null);
root.setLeftChild(p);
} else
insert(x, root.getLeftChild());
}
/**
* Finds the smallest element in the bst. This method invokes the overloaded
* method getMin, passing to it the root of the tree.
*
* @return the smallest element in the bst.
*/
public int getMin()
{
return getMin(root);
}
  
private Node root; //root of the bst. It's implemented as a dummy node.
/**
* Prints the elements of the subtree whose root is referenced by p. Uses
* inorder traversal.
*
* @param p root of subtree.
*/
private void inorderDisplay(Node p)
{
if (p != null)
{
inorderDisplay(p.getLeftChild());
System.out.print(p.getInfo() + " ");
inorderDisplay(p.getRightChild());
}
}
/**
* Finds if x is inserted in the subtree whose root is referenced by p. The
* search is conducted recursively, using the bst property: keys in the left
* subtree of a node are smaller than or equal to the key in the node, while
* the keys in the right subtree of the node are greater.
*
* @param x element to be found.
* @param p root of subtree.
* @return true if x is found in this subtree, false otherwise.
*/
private boolean search(int x, Node p)
{
if (p == null)
return false;
else if (x == p.getInfo())
return true;
else if (x < p.getInfo())
return search(x, p.getLeftChild());
else
return search(x, p.getRightChild());
}
/**
* Adds x to the subtree referenced by p. The search for the location to
* insert the new node is conducted recursively, using the bst property:
* keys in the left subtree of a node are smaller than or equal to the key
* in the node, while the keys in the right subtree of the node are greater.
*
* @param x element to be added to the subtree.
* @param p root of subtree.
*/
private void insert(int x, Node p)
{
if (x < p.getInfo())
if (p.getLeftChild() == null)
{
Node q = new Node();
q.setNode(x, null, null);
p.setLeftChild(q);
} else
insert(x, p.getLeftChild());
else if (p.getRightChild() == null)
{
Node q = new Node();
q.setNode(x, null, null);
p.setRightChild(q);
} else
insert(x, p.getRightChild());
}
/**
* Recursively finds the smallest element in the subtree referenced by p.
* The method uses this property of BSTs: the smallest value is stored in
* the leftmost node.
*
* @param p root of subtree.
* @return smallest element in the subtree referenced by p.
*/
private int getMin(Node p)
{
if (p.getLeftChild() == null)
return p.getInfo();
else
return getMin(p.getLeftChild());
}
}

//////////////////////////////Node
/**************************************
* Week 6 lab - exercise 1: *
* implementing a binary search tree *
***************************************/
/**
* Binary search tree node.
*/
class Node
{
private int info; //element stored in this node
private Node left; //link to left child
private Node right; //link to right child
/**
* Initializes this node setting info to 0 and left and right children to
* null.
*/
Node()
{
info = 0;
left = right = null;
}
/**
* Sets this node.
*
* @param x the desired value for this node.
* @param l node reference.
* @param r node reference.
*/
void setNode(int x, Node l, Node r)
{
info = x;
left = l;
right = r;
}
/**
* Returns the value in this node.
*
* @return the value in this node.
*/
int getInfo()
{
return info;
}
/**
* Returns the link to the left child.
*
* @return link to the left child.
*/
Node getLeftChild()
{
return left;
}
/**
* Returns the link to the right child.
*
* @return link to the right child.
*/
Node getRightChild()
{
return right;
}
/**
* Sets the value for this node.
*
* @param x the desired value for this node.
*/
void setInfo(int x)
{
info = x;
}
/**
* Sets the link to the left child.
*
* @param l node reference.
*/
void setLeftChild(Node l)
{
left = l;
}
/**
* Sets the link to the right child.
*
* @param r node reference.
*/
void setRightChild(Node r)
{
right = r;
}
}

Related Questions

Navigate

• Browse (All)
• Browse I
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.