// Binary Search Tree

#include<iostream.h>
#include<iomanip.h>
#include<conio.h>
#include<stdio.h>
#include<process.h>

struct Node
{
Node *Left ;
int data;
Node *Right;
};

typedef Node * NodePtr;

struct Snode
{
NodePtr ele ;
Snode *next ;
};

class Stack
{

private:

Snode *top;

public :

Stack()
{
top = NULL ;
}

void Push(NodePtr P)
{
Snode *temp;
temp = new Snode;
temp -> ele = P ;
temp -> next = top ;
 top = temp;
}

void Pop()
{
if( top != NULL )
{
NodePtr t;
Snode *temp;
temp = top;
top = top -> next ;
delete temp;
}
}

NodePtr Top()
{
if( top != NULL ) return top -> ele ;
else return NULL ;
}

int IsEmpty()
{
return ( ( top == NULL) ? 1 : 0 ) ;
}
};

class BST
{
public :
void Insert(int,NodePtr &);
void Delete(int,NodePtr &);
int DeleteMin(NodePtr &);
void Find(int,NodePtr &);
void Ances(int,NodePtr &);
void Desc(int,NodePtr &);
void PreOrder(NodePtr);
void InOrder(NodePtr);
void PostOrder(NodePtr);
void PreOrderNR(NodePtr);
void InOrderNR(NodePtr);
void PostOrderNR(NodePtr);
};
void BST :: Insert( int x , NodePtr &P)
{
if( P == NULL )
{
P = new Node;
P -> data = x ;
P -> Left = P -> Right = NULL ;
cout << "\n\n\tElement " << x << " Is Inserted Successfully" ;
}
else
{
if( x < P -> data ) Insert( x , P -> Left ) ;
else if( x > P -> data ) Insert( x , P -> Right) ;
else cout << "\n\n\t\tElement Already Exists !" ;
}
}

void BST :: Delete( int x , NodePtr &P)

{
NodePtr D;
if( P == NULL )
cout << "\n\n\t\tElement Is Not Found !" ;
else if( x < P -> data )
Delete( x , P -> Left );
else if( x > P -> data )
Delete( x , P -> Right );
else if( ( P -> Left == NULL ) && ( P -> Right == NULL ) )
{
D=P;
delete D ;
P = NULL ;
}
else if( P -> Left == NULL )
{
D=P;
P = P -> Right ;
delete D;
}
else if( P -> Right == NULL )
{
D=P;
P = P -> Left ;
delete D;
}
 else
P -> data = DeleteMin( P -> Right );
}

int BST :: DeleteMin(NodePtr &P)

{
int c ;
if( P -> Left == NULL )
{
c = P -> data ;
P = P -> Right;
return c;
}
else
DeleteMin( P -> Left ) ;
}

void BST :: Find( int x , NodePtr &P)

{
if( P == NULL )
cout << "\n\n\t\tThe Element Is Not Found" ;
else if( x > P -> data )
Find( x , P -> Right );
else if( x < P -> data )
Find( x , P -> Left );
else
cout << "\n\n\t\tElement Is Found" ;

void BST :: Ances( int x , NodePtr &P)

{
if( P == NULL )
cout << "\n\n\t\tThe Element Is Not Found" ;
else if( x > P -> data )
{
cout << setw(5) << P -> data ;
Ances(x,P->Right);
}
else if( x < P -> data )
{
cout << setw(5) << P -> data ;
Ances(x,P->Left);
}
}
void BST :: Desc( int x , NodePtr &P)
{
if( P == NULL )
cout << "\n\tThe Element Is Not Found" ;
else if( x > P -> data )
Desc( x , P -> Right );
else if( x < P -> data )
Desc( x , P -> Left );
else
{
PreOrder( P -> Left ) ;
PreOrder( P -> Right) ;
}
}

void BST :: PreOrder(NodePtr P)

{
if( P != NULL )
{
cout << setw(5) << P -> data ;
PreOrder( P -> Left );
PreOrder( P -> Right );
}
}

void BST :: InOrder(NodePtr P)

{
if( P != NULL )
{
InOrder( P -> Left ) ;
cout << setw(5) << P -> data ;
InOrder( P -> Right ) ;
}
}

void BST :: PostOrder(NodePtr P)

{
if( P != NULL )
{
PostOrder( P -> Left ) ;
PostOrder( P -> Right) ;
cout << setw(5) << P -> data ;
}
}
void BST :: PreOrderNR(NodePtr P)
{
Stack S;
while(1)
{
if( P != NULL )
{
cout << setw(5) << P -> data ;
S.Push(P);
P = P -> Left ;
}
else if(S.IsEmpty())
return ;
else
{
P = S.Top();
P = P -> Right ;
S.Pop();
}

}
}
void BST :: InOrderNR(NodePtr P)
{
Stack S;
while(1)
{
if( P != NULL )
{
S.Push(P);
P = P -> Left ;
}
else if(S.IsEmpty())
return;
else
{
NodePtr Temp;
Temp = S.Top();
cout << setw(5) << Temp -> data ;
P = Temp -> Right ;
S.Pop();
}
}
}
void BST :: PostOrderNR( NodePtr P )

Stack S;

while(1)
{

if( P != NULL )
{
S.Push(P);
P = P -> Left ;
}

else
{

if( S.IsEmpty() )
return ;

else if( S.Top() -> Right == NULL )

{
P = S.Top();
S.Pop();
cout << setw(5) << P -> data ;
}

if( P == S.Top() -> Right )

{
cout << setw(5) << S.Top() -> data ;
S.Pop();
}

if(!S.IsEmpty())

P = S.Top() -> Right ;

else
P = NULL ;
}
}
}
void main( )
{
BST B;
NodePtr Root = NULL;
int ele ;
char ch;
clrscr( );
while(1)
{
cout << "\n\nBINARY SEARCH TREE\n----------------------------" ;
cout << "\n1 . Insertion" ;
cout << "\n2 . Deletion" ;
cout << "\n3 . Find" ;
cout << "\n4 . Preorder" ;
cout << "\n5 . Inorder" ;
cout << "\n6 . Postorder" ;
cout << "\n7 . Exit" ;
cout << "\n\n\t\tEnter Ur Choice :: " ;
fflush(stdin);
ch = getchar( );
switch(ch)
{
case '1':
cout << "\n\nEnter Data Part Of The Node :: " ;
cin >> ele ;
B.Insert( ele , Root );
cout << "\n\n\t\tThe Inorder Traversal Is\n\n" ;
B.InOrder(Root);
break;
case '2':
cout << "\n\nEnter An Element That Is To Be Deleted ::" ;
cin >> ele ;
B.Delete( ele , Root );
cout << "\n\n\t\tThe Inorder Traversal Is\n\n" ;
B.InOrder(Root);
break;
case '3':
cout << "\n\nEnter An Element To Search ::" ;
cin >> ele ;
B.Find( ele , Root );
cout << "\n\n\t\tThe Ancestors Are \n\n" ;
B.Ances( ele , Root );
cout << "\n\n\t\tThe Descendants Are \n\n" ;
B.Desc( ele , Root );
break;
 case '4':
cout << "\n\nPREORDER" ;
if ( Root == NULL )
cout << "\n\n\t\tThe Tree Is Empty" ;
else
{
cout << "\nPreorder Traversal (Recursive) :: " ;
B.PreOrder(Root);
cout << "\nPreorder Traversal (Non Recursive) :: " ;
B.PreOrderNR(Root);
}
break ;
case '5':
cout << "\n\nINORDER" ;
if ( Root == NULL )
cout << "\n\n\t\tThe Tree Is Empty" ;
else
{
cout << "\nInorder Traversal (Recursive) :: " ;
B.InOrder(Root);
cout << "\nInorder Traversal (Non Recursive) :: " ;
B.InOrderNR(Root);
}
break ;
case '6':
cout << "\n\nPOSTORDER" ;
if ( Root == NULL )
cout << "\n\n\t\tThe Tree Is Empty" ;
else
{
cout << "\nPostorder Traversal (Recursive) :: " ;
B.PostOrder(Root);
cout << "\nPostorder Traversal (Non Recursive) :: " ;
B.PostOrderNR(Root);
}
break ;
default : exit(0);
}
}
}
Observations :

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 100
Element 100 Is Inserted Successfully

The Inorder Traversal Is

100

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 50
Element 50 Is Inserted Successfully

The Inorder Traversal Is

50 100

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 150
Element 150 Is Inserted Successfully

The Inorder Traversal Is

50 100 150

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 25
Element 25 Is Inserted Successfully

The Inorder Traversal Is

25 50 100 150

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 125
Element 125 Is Inserted Successfully

The Inorder Traversal Is

25 50 100 125 150

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 75
Element 75 Is Inserted Successfully

The Inorder Traversal Is

25 50 75 100 125 150

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 1
Enter Data Part Of The Node :: 175
Element 175 Is Inserted Successfully

The Inorder Traversal Is

25 50 75 100 125 150 175

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 3
Enter An Element To Search ::150

Element Is Found

The Ancestors Are

100

The Descendants Are

125 175
BINARY SEARCH TREE
----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 4

PREORDER
Preorder Traversal (Recursive) ::
100 50 25 75 150 125 175
Preorder Traversal (Non Recursive) ::
100 50 25 75 150 125 175

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 5

INORDER
Inorder Traversal (Recursive) ::
25 50 75 100 125 150 175
Inorder Traversal (Non Recursive) ::
25 50 75 100 125 150 175

BINARY SEARCH TREE

----------------------------
1 . Insertion
2 . Deletion
3 . Find
4 . Preorder
5 . Inorder
6 . Postorder
7 . Exit
Enter Ur Choice :: 7