Evaluating the Performance of Binary Search Tree The major advantage of binary search trees over other data structures is that the related sorting algorithms, search algorithms, insertion, and deletion can be very efficient when balanced. A binary search tree is an appropriate structure for many of the same applications discussed previously in conjunction with other collection structures, especially those providing sorted lists. The special advantage of using a binary search tree is that it facilitates searching while conferring the benefits of linking the elements. It provides the best features of both the sorted array-based list and the linked list. Similar to a sorted array-based list, it can be searched quickly, using a binary search. Similar to a linked list, it allows insertions and removals without having to move large amounts of data. Thus, a binary search tree is particularly well suited for applications in which processing time to insert, add and delete must be minimized. However, all aforementioned advantages are completed depend on how a tree was created. For example, in a balanced BST with N nodes, its minimum height is O(log n), it takes at maximum O(log n) comparisons to find a particular node. However, in the worst-case scenario, it takes up to O(n) comparisons to find a particular node. The following table summarizes the number of Nodes, height, and the number of comparisons to search a particular node in a balanced tree and the worst case. Example of Searching a Node in a Balanced Tree and the Worst Case Number of Nodes Height of the Tree Number of Comparisons Balanced Tree Worst Case Balanced Tree Worst Case 3 1 3 2 3 7 2 7 3 7 1024 9 1024 10 1024 4096 11 4096 12 4096 Your Tasks: For this assignment, you are required to design experiments to evaluate the relationship between BST tree height (h) and the number of comparisons to find a particular node in a tree.

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

I need help with this Java problem to output as it's explained in the image below:

/**
*
* Node.java: Node class //(Don't edit)
*/

public class Node implements NodeInterface<Integer>{

   private Integer data;
   private Node left;
   private Node right;

   public Node(int data){
      this.data =data; 
      left=right=null;
   }

   public Integer getData(){
      return data;
   }

   public Node getLeft(){
      return left;
   }

   public Node getRight(){
      return right;
   }

   public void setLeft(Node node){
      this.left = node;
   }

   public void setRight(Node node){
      this.right = node;
   }

   public String toString(){
      return ""+data;
   }
}

//(Don't edit)
interface NodeInterface<T>{
   T getData();
   NodeInterface<T> getLeft();
   NodeInterface<T> getRight();
}

/**
*
*
* MyIntBSTTree.txt: the template file of MyIntBSTTree.java
* Student tasks: implement tasks #1 and #2 as specified in this file
*/

import java.util.*;

public class MyIntBSTTree{  
   private Node root;
   public MyIntBSTTree(){
      root=null;
   }
   
   public int height(){
      // *** Student task ***  
      /* Requirements: 
        The height of a binary tree is the largest number of edges in a path from the root node to a leaf node. 
        Essentially, it is the height of the root node. Note that if a tree has only one node, then that node 
        is at the same time the root node and the only leaf node, so the height of the tree is 0, similary, 
        the height of a tree with only two nodes is 1. Implement this method to return height of the tree

       *** Enter your code below *** 
     */

     
      
   }
  
   public int comparisons(Node node){
      // *** Student task ***  
      /* Requirements: 
        Count and return how many comparisons performed to search for the argument node

       *** Enter your code below *** 
     */

     
      
   }
   public int comparisons(int val){

      // *** Student task ***  
      /* Requirements: 
       Overloaded method - Count and return how many comparisons performed to search for the node whose data equals the argument val.

       *** Enter your code below *** 
     */


   }

   public MyIntBSTTree buildBalancedTree(){
     
     // *** Student task ***  
      /* Requirements: 
         This method builds a balanced tree with values from the int arr and returns the new tree.
         The original tree remains unchanged after calling this method.
       *** Enter your code below *** 
     */


   }

   public MyIntBSTTree buildWorstTree(){
     
     // *** Student task ***  
      /* Requirements: 
         Build and return a tree whose height is arr.length - 1
         The original tree remains unchanged after calling this method.
       *** Enter your code below *** 
     */


   }

   
   // **** DO NOT MODIFY CODE BEYOND THIS POINT ***
   public Node getRoot(){
      return root;
   }
   public void add(int data) {
       root = addHelper(root, data);
   }

   private Node addHelper(Node node, int data) {//add node helper
       if (node == null){
          node = new Node(data);
       }else if (data <= node.getData()){
           node.setLeft(addHelper(node.getLeft(), data));
       }else{
           node.setRight(addHelper(node.getRight(), data));//System.out.println(data);
       }
       return node;
   }
 
}

 

Evaluating the Performance of Binary Search Tree
The major advantage of binary search trees over other data structures is that the related sorting algorithms, search algorithms, insertion,
and deletion can be very efficient when balanced. A binary search tree is an appropriate structure for many of the same applications
discussed previously in conjunction with other collection structures, especially those providing sorted lists. The special advantage of using
a binary search tree is that it facilitates searching while conferring the benefits of linking the elements. It provides the best features of both
the sorted array-based list and the linked list. Similar to a sorted array-based list, it can be searched quickly, using a binary search. Similar to
a linked list, it allows insertions and removals without having to move large amounts of data. Thus, a binary search tree is particularly well
suited for applications in which processing time to insert, add and delete must be minimized. However, all aforementioned advantages are
completed depend on how a tree was created. For example, in a balanced BST with N nodes, its minimum height is O(log n), it takes at
maximum O(log n) comparisons to find a particular node. However, in the worst-case scenario, it takes up to O(n) comparisons to find a
particular node. The following table summarizes the number of Nodes, height, and the number of comparisons to search a particular node
in a balanced tree and the worst case.
Example of Searching a Node in a Balanced Tree and the Worst Case
Number of Nodes
Height of the Tree
Number of Comparisons
Balanced Tree Worst Case Balanced Tree Worst Case
3
1
3
2
3
7
2
7
3
7
1024
9
1024
10
1024
4096
11
4096
12
4096
Your Tasks:
For this assignment, you are required to design experiments to evaluate the relationship between BST tree height (h) and the number of
comparisons to find a particular node in a tree.
Transcribed Image Text:Evaluating the Performance of Binary Search Tree The major advantage of binary search trees over other data structures is that the related sorting algorithms, search algorithms, insertion, and deletion can be very efficient when balanced. A binary search tree is an appropriate structure for many of the same applications discussed previously in conjunction with other collection structures, especially those providing sorted lists. The special advantage of using a binary search tree is that it facilitates searching while conferring the benefits of linking the elements. It provides the best features of both the sorted array-based list and the linked list. Similar to a sorted array-based list, it can be searched quickly, using a binary search. Similar to a linked list, it allows insertions and removals without having to move large amounts of data. Thus, a binary search tree is particularly well suited for applications in which processing time to insert, add and delete must be minimized. However, all aforementioned advantages are completed depend on how a tree was created. For example, in a balanced BST with N nodes, its minimum height is O(log n), it takes at maximum O(log n) comparisons to find a particular node. However, in the worst-case scenario, it takes up to O(n) comparisons to find a particular node. The following table summarizes the number of Nodes, height, and the number of comparisons to search a particular node in a balanced tree and the worst case. Example of Searching a Node in a Balanced Tree and the Worst Case Number of Nodes Height of the Tree Number of Comparisons Balanced Tree Worst Case Balanced Tree Worst Case 3 1 3 2 3 7 2 7 3 7 1024 9 1024 10 1024 4096 11 4096 12 4096 Your Tasks: For this assignment, you are required to design experiments to evaluate the relationship between BST tree height (h) and the number of comparisons to find a particular node in a tree.
Expert Solution
trending now

Trending now

This is a popular solution!

steps

Step by step

Solved in 2 steps

Blurred answer
Similar questions
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education