Question

please use java application to solve methods: 5,6,10,12,13 (no need for the rest)

Problem1: Create a new Java Application that has the following methods: 6 A method that generate a binary search tree (BST) where the number of nodes and the range of the values are 1. from a file. 2. A recursive method to print the BST in preorder traversal 3. A recursive method to print the BST in post-order traversal 4. A recursive method to print the BST in in-order traversal 5. A method to find the largest value in a BST 6. A method to find and return the smallest value in a BST 7. A method to search for a given value V in a BST 8. A recursive method to count the number of all nodes in BST . A method to count the number of leaf nodes in BST 10. A method to count the number of nodes that contain even numbers in a BST 11. A method to count the number of nodes with 2 children (child may be a single node or a sub-tree) 12. A method to check if two BSTs are identical or not 13. A method to print the BST in breadth first (Hint you need a queue to implement this method) Write the main method to test these methods described in 1 to 13

Answer 1

ALL COMBINED METHODS:

import java.util.Queue;
import java.util.LinkedList;
// class defining BST NODE
class Node{

   int value;
   Node left, right;

   Node(int value) { //constructor for assigning new node
       this.value = value;
       left = right = null;
   }
}

class BinarySearchTree {

   static Node head;
   //method to insert the value in the bst
   Node insert(Node node, int value) {
      
//if tree is empty insert at root
       if (node == null) {
           return (new Node(value));
       } else {
          
           // Otherwise,find the correct place
           if (value <= node.value) {
               node.left = insert(node.left,value);
           } else {
               node.right = insert(node.right,value);
           }

      
           return node;
       }
   }

//pass bst to find the minimum value
   int minimum(Node node) {
       Node temp = node;

       //minimum value is at the leftmost place so we keep on going down
       //the tree till we find leftmost node
       while (temp.left != null) {
           temp = temp.left;
       }
       return (temp.value);
   }
  
   int maximum(Node node) {
       Node temp = node;

       //minimum value is at the rightmost place so we keep on going down
       //the tree till we find leftmost node
       while (temp.right != null) {
           temp = temp.right;
       }
       return (temp.value);
   }
   //recucrsive class to count the number of even nodes in BST
   void countEvenRec(Node node,Count c){
   if(node==null)
   return;
   if(node.value%2==0)
   c.c_even++;
   countEvenRec(node.left,c);
   countEvenRec(node.right,c);
  
  
}
static class Count{ // class to sstore static variable to count even nodes
static int c_even;
}

int countEven(Node node){ // method to call the recursive method to count number of even nodes
Count c =new Count();
countEvenRec(node,c);
return c.c_even;
}

boolean Identical_Bst(Node root1, Node root2)
{
// Check if both the trees are empty
if (root1 == null && root2 ==null)
return true;
// If any one of the tree is non-empty
// and other is empty, return false
else if (root1 !=null && root2 ==null)
return false;
else if (root1 == null && root2 !=null)
return false;
else {
//simultaneously check for both the trees
//if both have same value at current node then identical otherwise not
if (root1.value == root2.value && Identical_Bst(root1.left, root2.left)
&& Identical_Bst(root1.right, root2.right))
return true;
else
return false;
}
}

void BFS(Node root)
{
Queue<Node> q = new LinkedList<Node>(); //create a q of nodes
q.add(root);
while (!q.isEmpty())
{
  
// pollremoves the present head.
Node temp = q.poll();
System.out.print(temp.value + " ");
  
/*Enqueue left child */
if (temp.left != null) {
q.add(temp.left);
}
  
/*Enqueue right child */
if (temp.right != null) {
q.add(temp.right);
}
}
}
  
}
public class Main{
   public static void main(String[] args) {
       BinarySearchTree t = new BinarySearchTree();
       Node root = null;
       root = t.insert(root,10);
       t.insert(root,25);
       t.insert(root,6);
       t.insert(root,4);
       t.insert(root,22);
       BinarySearchTree t1 = new BinarySearchTree();
       Node root1 = null;
       root1 = t.insert(root1,10);
       t.insert(root1,25);
       t.insert(root1,6);
       t.insert(root1,4);
       t.insert(root1,22);

System.out.println("Maximum value of BST is " + t.maximum(root));
System.out.println("Minimum value of BST is " + t.minimum(root));
System.out.println("Number of even value in BST is " + t.countEven(root));
if(t.Identical_Bst(root,root1))
System.out.println("BST 1 and 2 are identical");
else
System.out.println("BST 1 and 2 are not identical");
System.out.println("BFS traversal of tree 1 is ");
       t.BFS(root);
   }
}

INDIVIDUAL METHODS :

5)

int maximum(Node node) {
       Node temp = node;

       //minimum value is at the rightmost place so we keep on going down
       //the tree till we find leftmost node
       while (temp.right != null) {
           temp = temp.right;
       }
       return (temp.value);
   }

6)

int minimum(Node node) {
       Node temp = node;

       //minimum value is at the leftmost place so we keep on going down
       //the tree till we find leftmost node
       while (temp.left != null) {
           temp = temp.left;
       }
       return (temp.value);
   }

10)

   //recucrsive class to count the number of even nodes in BST
   void countEvenRec(Node node,Count c){
   if(node==null)
   return;
   if(node.value%2==0)
   c.c_even++;
   countEvenRec(node.left,c);
   countEvenRec(node.right,c);
  
  
}
static class Count{ // class to sstore static variable to count even nodes
static int c_even;
}

int countEven(Node node){ // method to call the recursive method to count number of even nodes
Count c =new Count();
countEvenRec(node,c);
return c.c_even;
}

12)

boolean Identical_Bst(Node root1, Node root2)
{
// Check if both the trees are empty
if (root1 == null && root2 ==null)
return true;
// If any one of the tree is non-empty
// and other is empty, return false
else if (root1 !=null && root2 ==null)
return false;
else if (root1 == null && root2 !=null)
return false;
else {
//simultaneously check for both the trees
//if both have same value at current node then identical otherwise not
if (root1.value == root2.value && Identical_Bst(root1.left, root2.left)
&& Identical_Bst(root1.right, root2.right))
return true;
else
return false;
}
}

13)

void BFS(Node root)
{
Queue<Node> q = new LinkedList<Node>(); //create a q of nodes
q.add(root);
while (!q.isEmpty())
{
  
// pollremoves the present head.
Node temp = q.poll();
System.out.print(temp.value + " ");
  
/*Enqueue left child */
if (temp.left != null) {
q.add(temp.left);
}
  
/*Enqueue right child */
if (temp.right != null) {
q.add(temp.right);
}
}
}
  
}