import java.util.

*; }
class BST public void insert(int data)
{ {
BST left, right; root = insert(root, data);
int data; }
public BST() private BST insert(BST node, int data)
{ {
left = null; if (node == null)
right = null; node = new BST(data);
data = 0; else
} {
if (data <= node.getData())
public BST(int n) node.left = insert(node.left, data);
{ else
left = null; node.right = insert(node.right,
right = null; data);
data = n; }
} return node;
}
public void setLeft(BST n) public void delete(int k)
{ {
left = n; if (isEmpty())
} System.out.println("Tree Empty");
public void setRight(BST n) else if (search(k) == false)
{ System.out.println("Sorry "+ k +" is
right = n; not present");
} else
public BST getLeft() {
{ root = delete(root, k);
return left; System.out.println(k+ " deleted
} from the tree");
public BST getRight() }
{ }
return right; private BST delete(BST root, int k)
} {
public void setData(int d) BST p, p2, n;
{ if (root.getData() == k)
data = d; {
} BST lt, rt;
public int getData() lt = root.getLeft();
{ rt = root.getRight();
return data; if (lt == null && rt == null)
} return null;
} else if (lt == null)
class BSTEx {
{ p = rt;
private BST root; return p;
}
public BSTEx() else if (rt == null)
{ {
root = null; p = lt;
} return p;
public boolean isEmpty() }
{ else
return root == null; {
 p2 = rt; found = search(r, val);
p = rt; }
while (p.getLeft() != null) return found;
p = p.getLeft(); }
p.setLeft(lt); public void inorder()
return p2; {
} inorder(root);
} }
if (k < root.getData()) private void inorder(BST r)
{ {
n = delete(root.getLeft(), k); if (r != null)
root.setLeft(n); {
} inorder(r.getLeft());
else System.out.print(r.getData() +" ");
{ inorder(r.getRight());
n = delete(root.getRight(), k); }
root.setRight(n); }
} public void preorder()
return root; {
} preorder(root);
public int countNodes() }
{ private void preorder(BST r)
return countNodes(root); {
} if (r != null)
private int countNodes(BST r) {
{ System.out.print(r.getData() +" ");
if (r == null) preorder(r.getLeft());
return 0; preorder(r.getRight());
else }
{ }
int l = 1; public void postorder()
l += countNodes(r.getLeft()); {
l += countNodes(r.getRight()); postorder(root);
return l; }
} private void postorder(BST r)
} {
public boolean search(int val) if (r != null)
{ {
return search(root, val); postorder(r.getLeft());
} postorder(r.getRight());
private boolean search(BST r, int val) System.out.print(r.getData() +" ");
{ }
boolean found = false; }
while ((r != null) && !found) }
{ public class BinarySearchTree
int rval = r.getData(); {
if (val < rval) public static void main(String[] args)
r = r.getLeft(); {
else if (val > rval) Scanner s1 = new Scanner(System.in);
r = r.getRight(); BSTEx bst = new BSTEx();
else System.out.println("Binary Search Tree
{ Test\n");
found = true; char ch;
break; do
} {
 System.out.println("\nBinary Search } while (ch == 'Y'|| ch == 'y');
Tree Operations\n"); }
System.out.println("1. insert "); }
System.out.println("2. delete");
System.out.println("3. search");
System.out.println("4. count nodes");
System.out.println("5. check
empty");

int choice = s1.nextInt();

switch (choice)
{
case 1 :
System.out.println("Enter integer
element to insert");
bst.insert( s1.nextInt() );
break;
case 2 :
System.out.println("Enter integer
element to delete");
bst.delete( s1.nextInt() );
break;
case 3 :
System.out.println("Enter integer
element to search");
System.out.println("Search result :
"+ bst.search(

s1.nextInt() ));
break;
case 4 :
System.out.println("Nodes = "+
bst.countNodes());
break;
case 5 :
System.out.println("Empty status
= "+ bst.isEmpty());
break;
default :
System.out.println("Wrong Entry
\n ");
break;
}
System.out.print("\nPost order : ");
bst.postorder();
System.out.print("\nPre order : ");
bst.preorder();
System.out.print("\nIn order : ");
bst.inorder();

System.out.println("\nDo you want

to continue (Type y or n)

\n");
ch = s1.next().charAt(0);