Homework Help Question & Answers

Please I need help ASAP Java Programing: Binary Search Tree Fully implement the BST class in Listing 25.4 (on page 961 of the 11th Edition of the text). Design and write a (main) driver program to com...

Please I need help ASAP

Java Programing: Binary Search Tree

Fully implement the BST class in Listing 25.4 (on page 961 of the 11th Edition of the text). Design and write a (main) driver program to completely test every method in the BST class to ensure the class meets all its requirements. You should read the Listing 25.5: TestBST.java for an idea of what your program should look like.

Listing 25.4 BST.java

public class BST>

extends AbstractTree {

protected TreeNode root;

protected int size = 0;

/** Create a default binary tree */

public BST() {

}

/** Create a binary tree from an array of objects */

public BST(E[] objects) {

for (int i = 0; i < objects.length; i++)

insert(objects[i]);

}

@Override /** Returns true if the element is in the tree */

public boolean search(E e) {

TreeNode current = root; // Start from the root

while (current != null) {

if (e.compareTo(current.element) < 0) {

current = current.left;

}

else if (e.compareTo(current.element) > 0) {

current = current.right;

}

else // element matches current.element

return true; // Element is found

}

return false;

}

@Override /** Insert element o into the binary tree

* Return true if the element is inserted successfully */

public boolean insert(E e) {

if (root == null)

root = createNewNode(e); // Create a new root

else {

// Locate the parent node

TreeNode parent = null;

TreeNode current = root;

while (current != null)

if (e.compareTo(current.element) < 0) {

parent = current;

current = current.left;

}

else if (e.compareTo(current.element) > 0) {

parent = current;

current = current.right;

}

else

return false; // Duplicate node not inserted

// Create the new node and attach it to the parent node

if (e.compareTo(parent.element) < 0)

parent.left = createNewNode(e);

else

parent.right = createNewNode(e);

}

size++;

return true; // Element inserted successfully

}

protected TreeNode createNewNode(E e) {

return new TreeNode<>(e);

}

@Override /** Inorder traversal from the root */

public void inorder() {

inorder(root);

}

/** Inorder traversal from a subtree */

protected void inorder(TreeNode root) {

if (root == null) return;

inorder(root.left);

System.out.print(root.element + " ");

inorder(root.right);

}

@Override /** Postorder traversal from the root */

public void postorder() {

postorder(root);

}

/** Postorder traversal from a subtree */

protected void postorder(TreeNode root) {

if (root == null) return;

postorder(root.left);

postorder(root.right);

System.out.print(root.element + " ");

}

@Override /** Preorder traversal from the root */

public void preorder() {

preorder(root);

}

/** Preorder traversal from a subtree */

protected void preorder(TreeNode root) {

if (root == null) return;

System.out.print(root.element + " ");

preorder(root.left);

preorder(root.right);

}

/** This inner class is static, because it does not access

any instance members defined in its outer class */

public static class TreeNode> {

public E element;

public TreeNode left;

public TreeNode right;

public TreeNode(E e) {

element = e;

}

}

@Override /** Get the number of nodes in the tree */

public int getSize() {

return size;

}

/** Returns the root of the tree */

public TreeNode getRoot() {

return root;

}

/** Returns a path from the root leading to the specified element */

public java.util.ArrayList> path(E e) {

java.util.ArrayList> list =

new java.util.ArrayList<>();

TreeNode current = root; // Start from the root

while (current != null) {

list.add(current); // Add the node to the list

if (e.compareTo(current.element) < 0) {

current = current.left;

}

else if (e.compareTo(current.element) > 0) {

current = current.right;

}

else

break;

}

return list; // Return an array list of nodes

}

@Override /** Delete an element from the binary tree.

* Return true if the element is deleted successfully

* Return false if the element is not in the tree */

public boolean delete(E e) {

// Locate the node to be deleted and also locate its parent node

TreeNode parent = null;

TreeNode current = root;

while (current != null) {

if (e.compareTo(current.element) < 0) {

parent = current;

current = current.left;

}

else if (e.compareTo(current.element) > 0) {

parent = current;

current = current.right;

}

else

break; // Element is in the tree pointed at by current

}

if (current == null)

return false; // Element is not in the tree

// Case 1: current has no left child

if (current.left == null) {

// Connect the parent with the right child of the current node

if (parent == null) {

root = current.right;

}

else {

if (e.compareTo(parent.element) < 0)

parent.left = current.right;

else

parent.right = current.right;

}

}

else {

// Case 2: The current node has a left child

// Locate the rightmost node in the left subtree of

// the current node and also its parent

TreeNode parentOfRightMost = current;

TreeNode rightMost = current.left;

while (rightMost.right != null) {

parentOfRightMost = rightMost;

rightMost = rightMost.right; // Keep going to the right

}

// Replace the element in current by the element in rightMost

current.element = rightMost.element;

// Eliminate rightmost node

if (parentOfRightMost.right == rightMost)

parentOfRightMost.right = rightMost.left;

else

// Special case: parentOfRightMost == current

parentOfRightMost.left = rightMost.left;

}

size--;

return true; // Element deleted successfully

}

@Override /** Obtain an iterator. Use inorder. */

public java.util.Iterator iterator() {

return new InorderIterator();

}

// Inner class InorderIterator

private class InorderIterator implements java.util.Iterator {

// Store the elements in a list

private java.util.ArrayList list =

new java.util.ArrayList<>();

private int current = 0; // Point to the current element in list

public InorderIterator() {

inorder(); // Traverse binary tree and store elements in list

}

/** Inorder traversal from the root*/

private void inorder() {

inorder(root);

}

/** Inorder traversal from a subtree */

private void inorder(TreeNode root) {

if (root == null)return;

inorder(root.left);

list.add(root.element);

inorder(root.right);

}

@Override /** More elements for traversing? */

public boolean hasNext() {

if (current < list.size())

return true;

return false;

}

@Override /** Get the current element and move to the next */

public E next() {

return list.get(current++);

}

@Override /** Remove the current element */

public void remove() {

delete(list.get(current)); // Delete the current element

list.clear(); // Clear the list

inorder(); // Rebuild the list

}

}

/** Remove all elements from the tree */

public void clear() {

root = null;

size = 0;

}

}

TestBST.java Listing

public class TestBST {

public static void main(String[] args) {

// Create a BST

BST tree = new BST<>();

tree.insert("George");

tree.insert("Michael");

tree.insert("Tom");

tree.insert("Adam");

tree.insert("Jones");

tree.insert("Peter");

tree.insert("Daniel");

// Traverse tree

System.out.print("Inorder (sorted): ");

tree.inorder();

System.out.print("\nPostorder: ");

tree.postorder();

System.out.print("\nPreorder: ");

tree.preorder();

System.out.print("\nThe number of nodes is " + tree.getSize());

// Search for an element

System.out.print("\nIs Peter in the tree? " +

tree.search("Peter"));

// Get a path from the root to Peter

System.out.print("\nA path from the root to Peter is: ");

java.util.ArrayList> path

= tree.path("Peter");

for (int i = 0; path != null && i < path.size(); i++)

System.out.print(path.get(i).element + " ");

Integer[] numbers = {2, 4, 3, 1, 8, 5, 6, 7};

BST intTree = new BST<>(numbers);

System.out.print("\nInorder (sorted): ");

intTree.inorder();

}

}

0 0
Next > < Previous
ReportAnswer #1

In this question, TestBST.java Listing contains the main method: Object declaration of class BST(string input) then it calls insert (insertion of tree nodes), then inorder transversal, followed by postorder transversal and then preorder transversal. After transversal we need to get total no of nodes using function defined as getsize(); Then we have to get path from one node; Now we again make an object of BST class(int input) then again calling inorder transversal.

//we have to overload insert method for both string input as well as integer input for integer we just directly compare with <, > comparator but in case of string use compareTo predefined java methods

void insert(int key) {
   root = insertRec(root, key);
}
  
Node insertRec(Node root, int key) {
  
if (root == null) {
root = new Node(key);
return root;
}
  
if (key < root.key)
root.left = insertRec(root.left, key);
else if (key > root.key)
root.right = insertRec(root.right, key);
  
return root;
}

@Override

public void insert(String root) {
if (this.root == null) {
this.root = root;
} else {
if (this.root.compareTo(root) < 0) {
if (this.left != null) {
this.left.addNode(root);
} else {
this.left = new BinaryStringTree(root);
}
} else {
if (this.right != null) {
this.right.addNode(root);
} else {
this.right = new BinaryStringTree(root);
}

}
}
}

void inorder() {
inorder1(root);
}

void inorder1(Node root) {
if (root != null) {
inorder1(root.left);
System.out.println(root.key);
inorder1(root.right);
   }
}

void preorder() {
    preorder1(root);
}

void preorder1(Node root) {
    if (root != null) {
       System.out.println(root.key);
        preorder1(root.left);
        preorder1(root.right);
    }
}

void postorder() {
    postorder1(root);
}

void postorder1(Node root) {
    if (root != null) {
        postorder1(root.left);
        postorder1(root.right);
       System.out.println(root.key);
    }
}

/*getsize is similar as well as path is similar only hack in this question is how to insert string because in case of BST left should be smaller than root and right should be greater than root. Further we compare it with such a way that any node in left can't be greater than root ie leaf(last node without any children) on right of predecessor is ok(ie say 4 is leaf and 2 is its current root) and if this root node is on left of another root(say 3) its fine but no this not bst as 4>3 hence unbalanced */

Know the answer?
Add Answer of:
Please I need help ASAP Java Programing: Binary Search Tree Fully implement the BST class in Listing 25.4 (on page 961 of the 11th Edition of the text). Design and write a (main) driver program to com...
Your Answer: Your Name: What's your source?
Not the answer you're looking for? Ask your own homework help question. Our experts will answer your question WITHIN MINUTES for Free.
Similar Homework Help Questions
  • write a new test program called RemoveDuplicates.java. The program reads text input from keyboard or a text file and adds the words to a BST. The program then traverses the BST and prints out the word...

    write a new test program called RemoveDuplicates.java. The program reads text input from keyboard or a text file and adds the words to a BST. The program then traverses the BST and prints out the words in order (based on ASCII/UNICODE order) on the screen (or to output text file). Note that you may need to make some changes to BST.java. Sample test: ----jGRASP exec: java -ea removeDuplicates Original Text: a B 2 n w C q K l 0...

  • Need Help with this java program. relating to BinaryTree

    Here is BinaryTree:public class BinaryTree>extends AbstractTree {protected TreeNode root;protected int size = 0;/** Create a default binary tree */public BinaryTree() {}/** Create a binary tree from an array of objects */public BinaryTree(E[] objects) {for (int i = 0; i < objects.length; i++)insert(objects[i]);}/** Returns true if the element is in the tree */public boolean search(E e) {TreeNode current = root; // Start from the rootwhile (current != null) {if (e.compareTo(current.element) < 0) {current = current.left;}else if (e.compareTo(current.element) > 0) {current =...

  • [c++]Binary search Tree balance method

    Hi guys.I need to make method called balance() to my BinarySearchTree class.I already made BST but I can't figure out the balance method.It is about converting BST into AVL i guess.have to follow the gven algorithm1. Copy the elements of the existing BST T, in orderm into a temporary vector v(so that the elements are sorted in increasing order)2.Create a new Empty BST newT.3.insert the elements of vector v into newT using the following recursive algorithm:recursiveInsert(v, lowIdx, highIdx, newT)if(lowIdx <=...

  • Binary Tree methods

    Hi! I need the rest of these methods filled in, will rate Lifesaver! :) Thank you!public class BinaryTree//definition of the nodeprotected class IntTreeNode{DataElement info;IntTreeNode left;IntTreeNode right;}{private IntTreeNode root;// pre : max > 0// post: constructs a sequential tree with given number of// nodespublic IntTree(int max){root = null}// post: returns a sequential tree with n as its root unless// n is greater than max, in which case it returns an// empty treeprivate IntTreeNode buildTree(int n, int max){if (n > max){return null;}...

  • In this assignment, you will add several methods to the Binary Search Tree. You should have compl...

    In this assignment, you will add several methods to the Binary Search Tree. You should have completed the following three methods in the lab: public void insert(Key key, Value value) public Value get(Key key) public void inorder(Node root) For this assignment, you will implement the following: public void remove(Node root, Key key) public Key getMin(Node n) public Key getMax(Node n) public int height(Node n) The main method contains the statements to check whether your implementation works. You need to change...

  • Binary Search tree Java program is 98% complete, need help with delete function. Will give 10 pts

    Ok, the code is almost done and I need help finishing up my deletefunction, I need to be able to delete the 50 and the 20.Hereis my code.public class BinarySearchTree{private class node{int data;node leftchild;node rightchild;}public BinarySearchTree(){ //create an empty Binary Search Tree }//node root = new node;root=null;}public boolean empty(){ // return true if the tree is empty, otherwise return false}if ( root == null ){return true;}else{return false;}}public void Insert(int x){//insert a value x }//search for a location to insertnode p=root;node...

  • Binary Search Tree Functions

    In this lab you will implement a Binary Search Tree (BST).• The BST should be able to hold a generic type. Use templates to help with that.• You should provide a useful interface for the BST. The header file BST.h should look as follows:#ifndef _BST_h#define _BST_h//includes if needed...template <class T>class Visitor;template <class T>class BSTNode {public:T data;BSTNode<T> * left;BSTNode<T> * right;return true if this node is a leaf node.bool isLeaf() const;// return true if the tree is emptybool isEmpty() const;// Find...

  • From the code below with Binary Search Tree recurrence T(n)=? use the recursion method and substitution method to solve the recurrence. Find the tightest bound g(n) for T(n) you can for which T(n)= O(...

    From the code below with Binary Search Tree recurrence T(n)=? use the recursion method and substitution method to solve the recurrence. Find the tightest bound g(n) for T(n) you can for which T(n)= O(g(n)). Explain your answer and use recursion tree method. void insert(int data) { struct node *tempNode = (struct node*) malloc(sizeof(struct node)); struct node *current; struct node *parent; tempNode->data = data; tempNode->leftChild = NULL; tempNode->rightChild = NULL; //if tree is empty if(root == NULL) { root = tempNode;...

  • Binary Search Tree Part A: The code attached in this document is a sample code to demonstrate ins...

    Binary Search Tree Part A: The code attached in this document is a sample code to demonstrate insert operation in binary search tree. Please fill in the missing part for the insert method to make the program work. The expected output should be as follows. 20 30 40 50 60 70 80 Part B: Find Lowest Common Ancestor (LCA) of a Binary Search Tree. According to WikiPedia definition , The lowest common ancestor is defined between two nodes v and...

  • using C++: Binary tree : please help out, I will rate a lifesaver...

    x.øi5ce="CourierNewPSMT" size="2">Please help me out with this assignment, I understand the theory behind the binary trees but my problem is implementing the code. I would appreciate help, I willrate lifesaver....Create a Visual C++ project using these files: binarySearchTree.h, binaryTree.h and labas05.cpp.(the files are at the end).Write the C++ code needed in file labas05.cpp for steps 1), 2), and 3).Write the C++ code needed in file binarySearchTree.h for steps 4) and 5).1. Declare the object states of type bSearchTreeType as a...

Need Online Homework Help?
Ask a Question
Get FREE Expert Answers
WITHIN MINUTES