Binary Search Tree

============================================
#include<conio.h>
#include<stdlib.h>
#include<process.h>
#include<iostream.h>

/*=========================== TreeNode
===========================*/

struct TreeNode{

TreeNode *right;
TreeNode *left;
int key;
};

struct StackNode{

StackNode *next;
TreeNode *operand;
};

/*=========================== Stack
===========================*/

class Stack{
public:

Stack(){runner=head=temp=NULL;}
~Stack(){}
void push(TreeNode *value);
TreeNode * pop();
int IsEmpty(){
if(head==NULL){ return 1;}
else return 0;
};
private:

StackNode *runner;
StackNode *head;
StackNode *temp;
};
/*=========================== Push
===========================*/

void Stack::push(TreeNode *value){

if(head==NULL){
head=(StackNode*)malloc(sizeof(StackNode));
head->operand=value;
head->next=NULL;
}
else
{
runner=head;
head=(StackNode*)malloc(sizeof(StackNode));
head->operand=value;
head->next=runner;

}
}

/*=========================== Pop
===========================*/

TreeNode* Stack::pop(){

temp=head;
head=head->next;
return temp->operand;
free(temp);
}

class Tree{
public:

Tree(){root=NULL;}
~Tree(){}

/*=========================== AddNode
===========================*/

void AddNode(int k){

if(root==NULL)
{
root=(TreeNode*)malloc(sizeof(TreeNode));
 root->key=k;
root->left=NULL;
root->right=NULL;
}
else
{
runner=root;
while(runner!=NULL)
{
if(k<=runner->key)
{
temp=runner;
runner=runner->left;

}
else
{
temp=runner;
runner=runner->right;
}
} // End of While

if(k<=temp->key)
{
temp-
>left=(TreeNode*)malloc(sizeof(TreeNode));
runner=temp->left;
}
else
{

temp-
>right=(TreeNode*)malloc(sizeof(TreeNode));
runner=temp->right;
}
runner->key=k;
runner->left=NULL;
runner->right=NULL;
}
}

/*=========================== Search
===========================*/
 int BinaryTreeSearch(int key)
{

runner=root;
int check=0;
while(runner!=NULL)
{
if(key<=runner->key)
{
temp=runner;
if(key==temp->key)
{
check=1;
break;
}
runner=runner->left;
}
else
{
temp=runner;
if(key==temp->key)
{
check=1;
break;
}
runner=runner->right;
}
}
if(check==1)
return temp->key;
else
return -1;
}

/*=========================== PreOrder
===========================*/

void PreOrder(TreeNode *ptr)

{
if(ptr!=NULL)
{
cout<<ptr->key<<endl;
PreOrder(ptr->left);
PreOrder(ptr->right);
 }
}

void DisplayPreOrder(){ PreOrder(root);}

/*=========================== PostOrder
===========================*/

void PostOrder(TreeNode *ptr)

{
if(ptr!=NULL)
{
PostOrder(ptr->left);
PostOrder(ptr->right);
cout<<ptr->key<<endl;
}
}

void DisplayPostOrder(){ PostOrder(root); }

/*=========================== InOrder
===========================*/

void InOrder(TreeNode *ptr)

{
if(ptr!=NULL)
{
InOrder(ptr->left);
cout<<ptr->key<<endl;
InOrder(ptr->right);
}
}

void DisplayInOrder(){ InOrder(root); }

/*=========================== Iterative PreOrder

===========================*/

void IPreOrder()
{
runner=root;
Stack s;
do{
 while(runner!=NULL)
{
cout<<runner->key<<endl;
if (runner->left != NULL)
s.push(runner);
temp = runner;
runner=runner->left;
}
// cout<< temp->key;
if(temp->right!=NULL)
runner=temp->right;
else{
do {
runner=s.pop();
}while (runner->right==NULL);
runner=runner->right;
}

}while(!s.IsEmpty() || runner !=NULL);

}

private:

TreeNode *runner;
TreeNode *root;
TreeNode *temp;
};

void main()
{
Tree t;
t.AddNode(11);
t.AddNode(7);
t.AddNode(18);
t.AddNode(3);
t.AddNode(10);
t.AddNode(15);
t.AddNode(22);
t.AddNode(9);
t.AddNode(21);
t.AddNode(1);
t.AddNode(5);
t.AddNode(13);
 t.AddNode(16);
t.AddNode(4);
t.AddNode(14);
//t.DisplayInOrder();
//t.DisplayPreOrder();
t.IPreOrder();
}

http://www.ravianeducation.blogspot.com
FARHAN: 03008855006