Please help me Asap !!! Given the followings: public class Node int expNum doubl
ID: 3903874 • Letter: P
Question
Please help me Asap !!!Given the followings: public class Node int expNum double resulti Node left, right; /assume the constructor, setters and getters are provided Write the following methods for a Binary Search Tree class: 1. public Boolean insert (int e, double r) 2. public Boolean remove (int e, double r) 3. public Boolean expNumExist (int e) 4. public Boolean resulrExist (int e) 5. public void printinOrder () 6. public void printPreOrder) 7. public void printPostOrder () 8. public int maximumExpNum () 9. public double maximumResult () 10. public double avgResult () 11. public int countResultGreaterThanX (double x) Note: 1. The insertion is based on the expNum. 2. You may need to use helper methods.
Explanation / Answer
import java.util.Scanner;
class Node
{
int expNum;
double result;
Node left, right;
public Node()
{
left = null;
right = null;
expNum = 0;
result = 0;
}
// constructor for Node
public Node(int expNum, double result)
{
left = null;
right = null;
this.expNum = expNum;
this.result = result;
}
// Function to set left node
public void setLeft(Node n)
{
left = n;
}
// Function to set right node
public void setRight(Node n)
{
right = n;
}
// Function to get left node
public Node getLeft()
{
return left;
}
// Function to get right node
public Node getRight()
{
return right;
}
// Function to set expNum to node
public void setexpNum(int expNum)
{
this.expNum = expNum;
}
// Function to get expNum from node
public int getexpNum()
{
return this.expNum;
}
// Function to set result to node
public void setresult(double result)
{
this.result = result;
}
// Function to get expNum from node
public double getresult()
{
return this.result;
}
}
// Class BST
class BST
{
private Node root;
/* Constructor */
public BST()
{
root = null;
}
/* Function to check if tree is empty */
public boolean isEmpty()
{
return root == null;
}
/* Functions to insert expNum */
public void insert(int e, double r)
{
root = insert(root, e, r);
}
/* Function to insert expNum recursively */
private Node insert(Node node, int expNum, double result)
{
if (node == null)
node = new Node(expNum, result);
else
{
if (expNum <= node.getexpNum())
node.left = insert(node.left, expNum, result);
else
node.right = insert(node.right, expNum, result);
}
return node;
}
public void remove(int e, double r)
{
if (isEmpty())
System.out.println("Tree Empty");
else if (search(e) == false||searchResult(r) == false)
System.out.println("Sorry "+ e +", "+r+" is not present");
else
{
root = delete(root, e, r);
System.out.println(e+ " deleted from the tree");
}
}
private Node delete(Node root, int e, double r)
{
Node p, p2, n;
if (root.getexpNum() == e&&root.getresult()==r)
{
Node lt, rt;
lt = root.getLeft();
rt = root.getRight();
if (lt == null && rt == null)
return null;
else if (lt == null)
{
p = rt;
return p;
}
else if (rt == null)
{
p = lt;
return p;
}
else
{
p2 = rt;
p = rt;
while (p.getLeft() != null)
p = p.getLeft();
p.setLeft(lt);
return p2;
}
}
if (e < root.getexpNum())
{
n = delete(root.getLeft(), e, r);
root.setLeft(n);
}
else
{
n = delete(root.getRight(), e, r);
root.setRight(n);
}
return root;
}
/* Functions to count number of nodes */
public int countNodes()
{
return countNodes(root);
}
/* Function to count number of nodes recursively */
private int countNodes(Node r)
{
if (r == null)
return 0;
else
{
int l = 1;
l += countNodes(r.getLeft());
l += countNodes(r.getRight());
return l;
}
}
public boolean expNumExist(int e)
{
return search(e);
}
/* Functions to search for an element */
public boolean search(int val)
{
return search(root, val);
}
/* Function to search for an element recursively */
private boolean search(Node r, int val)
{
boolean found = false;
while ((r != null) && !found)
{
int rval = r.getexpNum();
if (val < rval)
r = r.getLeft();
else if (val > rval)
r = r.getRight();
else
{
found = true;
break;
}
found = search(r, val);
}
return found;
}
public boolean resultExists(double r)
{
return searchResult(r);
}
public boolean searchResult(double val)
{
return searchResult(root, val);
}
/* Function to search for an element recursively */
private boolean searchResult(Node r, double val)
{
if(r==null) return false;
boolean found = false;
double rval = r.getresult();
if(rval==val) return true;
boolean right = searchResult(r.getRight(), val);
boolean left = searchResult(r.getLeft(), val);
found = right||left;
return found;
}
public int maximumExpNum(){
return maximumExpNum(root);
}
private int maximumExpNum(Node node){
if(node.right!=null){
return maximumExpNum(node.right);
}
else{
return node.getexpNum();
}
}
public Double maximumResult(){
double maxVal=0;
return maximumResult(root,maxVal);
}
private Double maximumResult(Node node,Double maxVal){
if(node==null) return maxVal;
double val = node.getresult();
if(val>maxVal) maxVal=val;
Double right = maximumResult(node.getRight(), val);
Double left = maximumResult(node.getLeft(), val);
if(left>right){
return left;
}
else{
return right;
}
}
public Double avgResult(){
double total = totalResult(root,0);
int nodeCount = countNodes();
return total/nodeCount;
}
private Double totalResult(Node node, double sum){
if(node==null) return 0.0;
Double val = node.getresult();
Double right = totalResult(node.getRight(), val);
Double left = totalResult(node.getLeft(), val);
return val+right+left;
}
public int countResultGreaterThanX(double x){
return countResultGreaterThanX(root,x);
}
private int countResultGreaterThanX(Node node,double x)
{
int result;
if(node==null) return 0;
Double val = node.getresult();
if(val>x)result = 1;
else result =0;
int right = countResultGreaterThanX(node.getRight(), x);
int left = countResultGreaterThanX(node.getLeft(), x);
return result+right+left;
}
/* Function for printprintInOrder traversal */
public void printInOrder()
{
printInOrder(root);
}
private void printInOrder(Node r)
{
if (r != null)
{
printInOrder(r.getLeft());
System.out.print("["+r.getexpNum() +", "+r.getresult()+"] ");
printInOrder(r.getRight());
}
}
/* Function for printPreOrder traversal */
public void printPreOrder()
{
printPreOrder(root);
}
private void printPreOrder(Node r)
{
if (r != null)
{
System.out.print("["+r.getexpNum() +", "+r.getresult()+"] ");
printPreOrder(r.getLeft());
printPreOrder(r.getRight());
}
}
/* Function for printPostOrder traversal */
public void printPostOrder()
{
printPostOrder(root);
}
private void printPostOrder(Node r)
{
if (r != null)
{
printPostOrder(r.getLeft());
printPostOrder(r.getRight());
System.out.print("["+r.getexpNum() +", "+r.getresult()+"] ");
}
}
}
/* Class BinarySearchTree */
public class BinarySearchTree
{
public static void main(String[] args)
{
/* Creating object of BST */
BST bst = new BST();
System.out.println("Binary Search Tree Test ");
bst.insert(10, 12.5);
bst.insert(9, 312.25);
bst.insert(1, 1.58);
bst.insert(8, 43.75);
bst.insert(112, 2.23);
bst.remove(9, 32.2);
bst.remove(8, 43.75);
bst.insert(6, 16.90);
bst.insert(16, 14.4);
bst.insert(19, 23.32);
bst.insert(3, 56.74);
/* Display tree */
System.out.print(" Post order : ");
bst.printPostOrder();
System.out.print(" Pre order : ");
bst.printPreOrder();
System.out.print(" In order : ");
bst.printInOrder();
System.out.println(" Nodes = "+ bst.countNodes());
System.out.println("Maximum Result "+bst.maximumResult());
System.out.println("Maximum expNum "+bst.maximumExpNum());
System.out.println("Average Result "+bst.avgResult());
System.out.println("count greater than 12 --> "+bst.countResultGreaterThanX(12));
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.