Question

Write a Java program named BSTree.java that will:

1) Generate 20 random integer numbers ranging from 1-99.

2) Build a Binary Search Tree using this set of numbers. Write the add method.

3) After building the tree, display the data into three formats: prefix order, infix order, and postfix order.

4) Write a method to delete an element from the Binary Search Tree. First search the item in your TREE and then delete it.

Answer 1

Code:

import java.util.*;

//Creating Node with Basic Functionalities
class BSTNode
{
     BSTNode left, right;
     int data;
     //An empty node
     public BSTNode()
     {
         left = null;
         right = null;
         data = 0;
     }
    //Creating a node with value n
     public BSTNode(int n)
     {
         left = null;
         right = null;
         data = n;
     }
     //Setting left node
     public void setLeft(BSTNode n)
     {
         left = n;
     }
    //Setting right node
     public void setRight(BSTNode n)
     {
         right = n;
     }
     //Function returns left node
     public BSTNode getLeft()
     {
         return left;
     }
     //Function returns right node
     public BSTNode getRight()
     {
         return right;
     }
     //Setting data to node
     public void setData(int d)
     {
         data = d;
     }
     //Getting data of node
     public int getData()
     {
         return data;
     }   
}

class BST
{
     BSTNode root;

     //Initially tree is null
     public BST()
     {
         root = null;
     }
     //Checking tree is empty or not
     public boolean isEmpty()
     {
         if(root == null)
           return true;
       else
           return false;
     }
   //Public method to get call from Main method of other class
   //Private method to get call from within the class
     public void add(int data)
     {
         root = add(root, data);
     }
    //Method to insert data
     private BSTNode add(BSTNode node, int data)
     {
       //If tree is empty then newNode will become root
         if (node == null)
             node = new BSTNode(data);
         //If tree is non empty
       else
         {
           //new node data is less than parent data then make it as left child
           //Otherwise make it as right child
             if (data < node.getData())
                 node.left = add(node.left, data);
             else
                 node.right = add(node.right, data);
         }
         return node;
     }
   public void prefixOrder()
   {
       prefixOrder(root);
   }
   //Preorder is root->left->right
   private void prefixOrder(BSTNode r)
     {
         if (r != null)
         {
             System.out.print(r.getData() +" ");
             prefixOrder(r.getLeft());           
             prefixOrder(r.getRight());
         }
     }
   public void infixOrder()
   {
       infixOrder(root);
   }
   //Inorder is left->root->right
   private void infixOrder(BSTNode r)
     {
         if (r != null)
         {
             infixOrder(r.getLeft());
           System.out.print(r.getData() +" ");
             infixOrder(r.getRight());
         }
     }
   public void postfixOrder()
   {
       postfixOrder(root);
   }
   //Postorder is left->right->root
   private void postfixOrder(BSTNode r)
     {
         if (r != null)
         {
             postfixOrder(r.getLeft());           
             postfixOrder(r.getRight());
           System.out.print(r.getData() +" ");
         }
     }
  
     public boolean search(int val)
     {
         return search(root, val);
     }
     //Method to search element
     private boolean search(BSTNode r, int val)
     {
         boolean found = false;
         while ((r != null) && !found)
         {
             int rval = r.getData();
           //If searching value is less that current node data then go left
             if (val < rval)
                 r = r.getLeft();
           //If searching value is less that current node data then go right
             else if (val > rval)
                 r = r.getRight();
           //If value is equal to current node data
             else
             {
                 found = true;
                 break;
             }
             found = search(r, val);
         }
         return found;
     }
  
   public void delete(int k)
     {
         if (isEmpty())
             System.out.println("Tree Empty");
         else if (search(k) == false)
             System.out.println("Sorry "+ k +" is not present");
         else
         {
             root = delete(root, k);
             System.out.println(k+ " deleted from the tree");
           System.out.println("\nAfter Deletion");
           System.out.println("\nPrefix order: ");prefixOrder();
           System.out.println("\nInfix order: ");infixOrder();
           System.out.println("\nPostfix order: ");postfixOrder();
         }
     }
     private BSTNode delete(BSTNode root, int k)
     {
         BSTNode p, p2, n;
       //If desired value found
         if (root.getData() == k)
         {
             BSTNode lt, rt;
             lt = root.getLeft();
             rt = root.getRight();
           //If single node present in tree
             if (lt == null && rt == null)
                 return null;
           //If node doesn't contain left node
             else if (lt == null)
             {
                 p = rt;
                 return p;
             }
           //If node doesn't contain right node
             else if (rt == null)
             {
                 p = lt;
                 return p;
             }
           //If node contains both the children
             else
             {
                 p2 = rt;
                 p = rt;
                 while (p.getLeft() != null)
                     p = p.getLeft();
                 p.setLeft(lt);
                 return p2;
             }
         }
       //If desired value is less than current node value then go left
         if (k < root.getData())
         {
             n = delete(root.getLeft(), k);
             root.setLeft(n);
         }
       //If desired value is greater than current node value then go right
         else
         {
             n = delete(root.getRight(), k);
             root.setRight(n);           
         }
         return root;
     }
}
public class BSTree
{
    public static void main(String args[])
    {
       //Creating object to Random() class
        Random r=new Random();
       //Creating object to BST class
       BST bst = new BST();
       //Generating 20 random numbers
        for(int i=0;i<20;)
       {
           int value=r.nextInt(100);
           if(value!=0)
           {
               bst.add(value);
               i++;
           }
       }
       System.out.println("\nPrefix order: ");bst.prefixOrder();
       System.out.println("\nInfix order: ");bst.infixOrder();
       System.out.println("\nPostfix order: ");bst.postfixOrder();
       Scanner sc=new Scanner(System.in);
       System.out.print("\nEnter deleting node value: ");
       int deleteValue=sc.nextInt();
       bst.delete(deleteValue);
    }
}

Output Screenshot: