Question

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 w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself). Write a function (Find Lowest Common Ancestor (LCA) of a Binary Search Tree) within the BinarySearchTree class in Part A and output test results.

Sample input: v: node 20, w: node 40. Expected output: node 30

Sample input: v: node 60, w: node 80. Expected output: node 70

Sample input: v: node 30, w: node 70. Expected output: node 50

// Java program to demonstrate insert operation in binary search tree

class BinarySearchTree {

            /* Class containing left and right child of current node and key value*/

            class Node {

                        int key;

                        Node left, right;

                        public Node(int item) {

                                    key = item;

                                    left = right = null;

                        }

            }

            // Root of BST

            Node root;

            // Constructor

            BinarySearchTree() {

                        root = null;

            }

            // This method mainly calls insertRec()

            void insert(int key) {

            root = insertRec(root, key);

            }

           

            /* A recursive function to insert a new key in BST */

            Node insertRec(Node root, int key) {

                        /* If the tree is empty, return a new node */

                        if (root == null) {

                                    root = new Node(key);

                                    return root;

                        }

                        /* Otherwise, recur down the tree */

                         Add your code here.

                         

                        /* return the (unchanged) node pointer */

                        return root;

            }

            // This method mainly calls InorderRec()

            void inorder() {

            inorderRec(root);

            }

            // A utility function to do inorder traversal of BST

            void inorderRec(Node root) {

                        if (root != null) {

                                    inorderRec(root.left);

                                    System.out.println(root.key);

                                    inorderRec(root.right);

                        }

            }

            // Driver Program to test above functions

            public static void main(String[] args) {

                        BinarySearchTree tree = new BinarySearchTree();

                        /* Let us create following BST

                        tree.insert(50);

                        tree.insert(30);

                        tree.insert(20);

                        tree.insert(40);

                        tree.insert(70);

                        tree.insert(60);

                        tree.insert(80);

                        // print inorder traversal of the BST

                        tree.inorder();

            }

}

Answer 1

PART A: BinarySearchTree.java:

// Java program to demonstrate insert operation in binary search tree

class BinarySearchTree {

/* Class containing left and right child of current node and key value*/

class Node {

int key;

Node left, right;

public Node(int item) {

key = item;

left = right = null;

}

}

// Root of BST

Node root;

// Constructor

BinarySearchTree() {

root = null;

}

// This method mainly calls insertRec()

void insert(int key) {

root = insertRec(root, key);

}

/* A recursive function to insert a new key in BST */

Node insertRec(Node root, int key) {

/* If the tree is empty, return a new node */

if (root == null) {

root = new Node(key);

return root;

}

/* Otherwise, recur down the tree */

if(key < root.key)
                           root.left = insertRec(root.left, key);
                       else if(key > root.key)
                           root.right = insertRec(root.right, key);
                      

/* return the (unchanged) node pointer */

return root;

}

// This method mainly calls InorderRec()

void inorder() {

inorderRec(root);

}

// A utility function to do inorder traversal of BST

void inorderRec(Node root) {

if (root != null) {

inorderRec(root.left);

System.out.println(root.key);

inorderRec(root.right);

}

}

// Driver Program to test above functions

public static void main(String[] args) {

BinarySearchTree tree = new BinarySearchTree();

/* Let us create following BST
                                   50
                               / \
                               30 70
                               / \ / \
                           20 40 60 80 */

tree.insert(50);

tree.insert(30);

tree.insert(20);

tree.insert(40);

tree.insert(70);

tree.insert(60);

tree.insert(80);

// print inorder traversal of the BST

tree.inorder();

}

}

Output:

File Microsoft Windows [Version 18.e.17763.379] c) 2018 Microsoft Corporation. All rights reserved. EPSON ONC:\Users Kotha Rudra Tej\Documents>javac Main.java :\Users\Kotha Rudra Tej\Documents>java Main Error: Could not find or load main class Main :\Users\Kotha Rudra Tej\Documents java BinarySearchTree 48 7e :\Users\Kotha Rudra Tej\Documents> 8 items O Type here to search ое 7:28 AM 3/23/2019

PART B:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// Java program to demonstrate insert operation in binary search tree

class BinarySearchTree {

/* Class containing left and right child of current node and key keyue*/

class Node {

int key;

Node left, right;

public Node(int item) {

key = item;

left = right = null;

                       }
}
      
      
          

// Root of BST

Node root;

// Constructor

BinarySearchTree() {

root = null;

}

// This method mainly calls insertRec()

void insert(int key) {

root = insertRec(root, key);

}

/* A recursive function to insert a new key in BST */

Node insertRec(Node root, int key) {

/* If the tree is empty, return a new node */

if (root == null) {

root = new Node(key);

return root;

}

/* Otherwise, recur down the tree */

if(key < root.key)
                           root.left = insertRec(root.left, key);
                       else if(key > root.key)
                           root.right = insertRec(root.right, key);
                      

/* return the (unchanged) node pointer */

return root;

}

// This method mainly calls InorderRec()

void inorder() {

inorderRec(root);

}

// A utility function to do inorder traversal of BST

void inorderRec(Node root) {

if (root != null) {

inorderRec(root.left);

System.out.println(root.key);

inorderRec(root.right);

}

}
               //Lowest Common Ancestor
               private List<Integer> path1= new ArrayList<>();
               private List<Integer> path2= new ArrayList<>();

               //find the path from root node to given root of the tree
               int findLCA(int n1,int n2)
               {
                   path1.clear();
                   path2.clear();
                   return findLCAInternal(root,n1,n2);
               }

               private int findLCAInternal(Node root , int n1, int n2)
               {
                   if(!findpath(root,n1,path1) || !findpath(root,n2,path2))
                   {
                       System.out.println(path1.size() > 0 ? "n1 is present" : "n1 is missing");
                       System.out.println(path2.size() > 0 ? "n2 is present" : "n2 is missing");
                       return -1;
                   }
                   int i;
                   for(i=0; i < path1.size() && i < path2.size(); i++)
                   {
                   // System.out.println(path1.get(i) + " " + path2.get(i));
                   if (!path1.get(i).equals(path2.get(i)))
                       break;
                   }
                   return path1.get(i-1);
               }

               //Finds the path from root node to given root of the tree, stores the path in a vector path[],
               //returns true if path exists , otherwsie returns fals

               private boolean findpath(Node root , int n, List<Integer> path)
               {
                   if(root==null)
                   {
                       return false;
                   }
                      
                   //stores this node. The node will be removed if not in path from root to n.
                   path.add(root.key);
                   if(root.key == n) {
                       return true;
                   }
                   if(root.left!= null && findpath(root.left , n , path)) {
                       return true;
                   }
                   if(root.right!= null && findpath(root.right , n , path)) {
                       return true;
                   }
                   // If not present in subtree rooted with root, remove root from path[] and return false
                  
                   path.remove(path.size()-1);
                   return false;
                  
               }
      
  
  
// Driver Program to test above functions
public static void main(String[] args) {
BinarySearchTree tree = new BinarySearchTree();
/* Let us create following BST
                                   50
                               / \
                               30 70
                               / \ / \
                           20 40 60 80 */

tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(40);
tree.insert(70);
tree.insert(60);
tree.insert(80);
// print inorder traversal of the BST
tree.inorder();
                       //reading values and printing lowest common ancestor
                       Scanner input= new Scanner(System.in);
                       System.out.println("Enter V and W nodes");
                       int v=input.nextInt();
                       int w=input.nextInt();
                       System.out.println("LCA(v,w): is " + tree.findLCA(v,w));
                      

}

}

Output:

C: \Users\Kotha Rudra Tej\Documents>java BinarySearchTree 2e за 4e 50 6e 7e Enter V and W nodes 2e 4e LCA(v,w): is 3e C:NUsers\Kotha Rudra Tej\Documents>javac Main.java C:NUsers\Kotha Rudra Tej\Documents>java BinarySearchTree 20 30 4e 50 60 80 Enter V and W nodes 60 LCA(v,w): is 7e C: Users Kotha Rudra Tej\Documentss O Type here to search 8-52 AM E 3/23/2019