168 lines
3.7 KiB
C++
168 lines
3.7 KiB
C++
#include<iostream>
|
|
#include<stack>
|
|
#define endl "\n"
|
|
using namespace std;
|
|
|
|
|
|
// Basic Structure of a Tree
|
|
struct Node{
|
|
int data;
|
|
struct Node *left;
|
|
struct Node *right;
|
|
|
|
Node(int val){
|
|
data = val;
|
|
left = NULL;
|
|
right = NULL;
|
|
}
|
|
};
|
|
|
|
/* Pre, In and Post order Traversal of a Binary Tree using recusrion */
|
|
/* Complexity for each Traversal : O(n) */
|
|
|
|
// LST -> Left SubTree RST -> Right SubTree
|
|
|
|
// Pre-Order goes like :- Root, LST, RST (Recursively)
|
|
void pre_order(struct Node* root){
|
|
if(root == NULL)
|
|
return;
|
|
cout<<root->data<<" ";
|
|
pre_order(root->left);
|
|
pre_order(root->right);
|
|
}
|
|
|
|
// In-Order goes like :- LST, Root, RST (Recursively)
|
|
void in_order(struct Node* root){
|
|
if(root == NULL)
|
|
return;
|
|
in_order(root->left);
|
|
cout<<root->data<<" ";
|
|
in_order(root->right);
|
|
}
|
|
|
|
// Pre-Order goes like :- LST, RST, Root (Recursively)
|
|
void post_order(struct Node* root){
|
|
if(root == NULL)
|
|
return;
|
|
post_order(root->left);
|
|
post_order(root->right);
|
|
cout<<root->data<<" ";
|
|
}
|
|
|
|
|
|
/* Pre, In and Post order Traversal of a Binary Tree using Iteration */
|
|
/* Complexity for each Traversal : O(n) */
|
|
|
|
|
|
void NRpreorder(struct Node* root) //Iterative Preorder Traversal
|
|
{
|
|
stack <Node*> s;
|
|
while(!s.empty() || root!=NULL)
|
|
{
|
|
while(root!=NULL)
|
|
{
|
|
cout<<root->data<<" ";
|
|
s.push(root);
|
|
root=root->left;
|
|
}
|
|
root=s.top();
|
|
s.pop();
|
|
root=root->right;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void NRinorder(struct Node* root) //Iterative Inorder Traversal
|
|
{
|
|
stack <Node*> s;
|
|
while(!s.empty() || root!=NULL)
|
|
{
|
|
while(root!=NULL)
|
|
{
|
|
s.push(root);
|
|
root=root->left;
|
|
}
|
|
root=s.top();
|
|
s.pop();
|
|
cout<<root->data<<" ";
|
|
root=root->right;
|
|
}
|
|
}
|
|
|
|
|
|
void NRpostorder(struct Node* root) //Iterative Postorder Traversal
|
|
{
|
|
stack <Node*> s1;
|
|
stack <int> s2;
|
|
while(root!=NULL)
|
|
{
|
|
s1.push(root);
|
|
s2.push(0);
|
|
root=root->left;
|
|
}
|
|
while(!s1.empty())
|
|
{
|
|
root=s1.top();
|
|
if(s2.top()==1)
|
|
{
|
|
s1.pop();
|
|
s2.pop();
|
|
cout<<root->data<<" ";
|
|
}
|
|
else
|
|
{
|
|
s2.top()=1;
|
|
root=root->right;
|
|
while(root!=NULL)
|
|
{
|
|
s1.push(root);
|
|
s2.push(0);
|
|
root=root->left;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int main(){
|
|
Node* root = new Node(1);
|
|
root->left = new Node(2);
|
|
root->right = new Node(3);
|
|
root->left->left = new Node(4);
|
|
root->left->right = new Node(5);
|
|
root->right->right = new Node(7);
|
|
|
|
/*
|
|
1
|
|
/ \
|
|
2 3
|
|
/ \ \
|
|
4 5 7
|
|
Expected-> From Recursive calls :
|
|
pre-order : 1 2 4 5 3 7
|
|
in-order : 4 2 5 1 3 7
|
|
post-order : 4 5 2 7 3 1
|
|
|
|
From Non-Recursive/Iterative calls :
|
|
preorder : 1 2 4 5 3 7
|
|
inorder : 4 2 5 1 3 7
|
|
postorder : 4 5 2 7 3 1
|
|
|
|
*/
|
|
// Tree Traversal using recursive calls
|
|
cout<<"From Recursive calls : "; cout<<endl;
|
|
cout<<"pre-order : "; pre_order(root); cout<<endl;
|
|
cout<<"in-order : "; in_order(root); cout<<endl;
|
|
cout<<"post-order : "; post_order(root); cout<<endl<<endl;
|
|
|
|
// ~~~~~~ Tree Traversal using non-recusive/Iterative calls ~~~~~~
|
|
cout<<"From Non-Recursive/Iterative calls : "; cout<<endl;
|
|
cout<<"preorder : "; NRpreorder(root); cout<<endl;
|
|
cout<<"inorder : "; NRinorder(root); cout<<endl;
|
|
cout<<"postorder : "; NRpostorder(root); cout<<endl;
|
|
|
|
return 0;
|
|
}
|