classBSTNode {

int data;
BSTNode left;
BSTNode right;
BSTNode(int d ) // constructor
{ data = d; } }
classBinarySearchTree
{ publicBSTNodeinsertTree(BSTNode p, int key) // create BST {
if( p == null )
p = new BSTNode(key);
else if( key <p.data)
p.left = insertTree(p.left, key);
elsep.right = insertTree( p.right, key);
return p; // return root }
publicBSTNode search(BSTNode root, int key) {
BSTNode p = root; // initialize p with root
while( p != null )
{ if( key == p.data ) return p;
else if( key <p.data ) p = p.left;
else p = p.right; }
return null; }
publicintleafNodes(BSTNode p) {
int count = 0;
if( p != null)
{ if((p.left == null) && (p.right == null))
count = 1;

else
count = count + leafNodes(p.left)
+ leafNodes(p.right); }
return count; }
publicBSTNodedeleteTree(BSTNode root, int key) {
BSTNode p; // refer to node to be deleted
BSTNode parent = root; // refer to parent of node to be deleted
BSTNodeinorderSucc; //refer to inordersucc. of node to be deleted
if(root == null)
{ System.out.println("Tree is empty");
return null; }
p = root; // initialize p with root
/* find node being deleted & its parent */

while( p != null &&p.data !

= key)
{ parent = p;
if( key <p.data) p = p.left;
else p = p.right; }
if( p == null )
{ System.out.println("\n Node " + key + " not found for deletion");
return null; }
/* find inorder successor of the node being deleted and its parent */
if(p.left != null &&p.right != null) // case-3
{ parent = p;
inorderSucc = p.right;
while(inorderSucc.left != null) {
parent = inorderSucc;
inorderSucc = inorderSucc.left; }

p.data = inorderSucc.data;

p = inorderSucc; }

if(p.left == null &&p.right == null) // case-1 {

if(parent.left == p ) parent.left = null;
elseparent.right = null; }
if(p.left == null &&p.right != null) // case-2(a) {
if(parent.left == p) parent.left = p.right;
elseparent.right = p.right; }
if(p.left != null &&p.right == null)

// case-2(b) {

if(parent.left == p) parent.left = p.left;

elseparent.right = p.left; }

return root; }

public void inorder(BSTNode p) // 'p' starts with root

{ if( p != null )
{ inorder(p.left);

System.out.print(p.data + " ");

inorder(p.right); } }
public void preorder(BSTNode p)
{ if( p != null )
{ System.out.print(p.data + " ");
preorder(p.left);
preorder(p.right); } }
public void postorder(BSTNode p)
{ if( p != null )
{ postorder(p.left);

postorder(p.right);

System.out.print(p.data + " "); } }

} // end of BinarySearchTree class
////////////////////// BinarySearchTreeDemo.java////////////////////
classBinarySearchTreeDemo

{ public static void main(String args[])

{
intarr[] = { 45, 25, 15, 10, 20, 30, 65, 55, 50, 60, 75, 80 };
BinarySearchTreebst = new BinarySearchTree();
BSTNode root = null;
// build tree by repeated insertions
for(int i = 0; i <arr.length; i++ )
root = bst.insertTree( root, arr[i]);
BSTNode root2 = root; // copy BST
int key = 66;
BSTNode item = bst.search(root2, key);
if( item != null )
System.out.print("\n item found: " + item.data);
elseSystem.out.print("\n Node " + key + " not found");
System.out.print("\n Number of leaf nodes: " + bst.leafNodes(root));
System.out.print("\n Inorder: ");
bst.inorder(root);
System.out.print("\n Preorder: ");
bst.preorder(root);
System.out.print("\n Postorder: ");
bst.postorder(root);
key = 55; // delete 55
bst.deleteTree(root, key);
System.out.print("\n Inorder, after deletion of " + key + ": ");
bst.inorder(root);

key = 66; // insert 66

bst.insertTree(root, key);

System.out.print("\n Inorder, after insertion of " + key + ": ");

bst.inorder(root); } }

Output: