CODE

template<class T>
struct Node{
T data;
struct Node* link;
};
template<class T>
class stack{
struct Node<T>* top=NULL;
public:
void push(T data);
void pop();
T peek();
bool isempty();
};
template<class T>
bool stack<T>::isempty(){
return top==NULL;
}
template<class T>
void stack<T>::push(T data){
struct Node<T>* temp;
temp=new Node<T>();
if(!temp){
cout<<"Heap overflow"<<endl;
}
temp->data=data;
temp->link=top;
top=temp;
}
template<class T>
T stack<T>::peek(){
return top->data;
}
template<class T>
void stack<T>::pop(){
struct Node<T>* temp=new Node<T>();
if (!isempty()){
temp=top;
top=top->link;
temp->link=NULL;
delete temp;
}
}

#ifndef TREE_HEADER_H_
#define TREE_HEADER_H_
struct treenode{
char data;
treenode *lchild;
 treenode *rchild;
};
class expTree{
treenode *root;
public:
expTree();
void createTree(string exp);
bool isOpera(char);
treenode*getTreeNode(char);
treenode*getroot();
//Recursive Traversals
void RInorderTraversal(treenode*);
void RPreorderTraversal(treenode*);
void RPostorderTraversal(treenode*);
//Non Recursive Traversals
void NRInorderTraversal(treenode*);
void NRPreorderTraversal(treenode*);
void NRPostorderTraversal(treenode*);
};
#endif

#include <iostream>
using namespace std;
#include "tree_header.h"
#include "stack.h"
expTree::expTree(){
root = NULL;
}
void expTree::createTree(string exp){
int i = 0;
treenode *temp;
stack<treenode *> expTrStk;
while (exp[i] != '\0')
{
temp = getTreeNode(exp[i]);
if (!isOpera(exp[i])){
expTrStk.push(temp);
}
else {
temp->rchild = expTrStk.peek();
expTrStk.pop();
temp->lchild = expTrStk.peek();
expTrStk.pop();
expTrStk.push(temp);
}
i++;
}
root = expTrStk.peek();
expTrStk.pop();
}
bool expTree::isOpera(char op){
if (op == '+' || op == '-' || op == '*' || op == '/' || op == '%' || op == '^'){
return true;
}
return false;
}
treenode *expTree::getTreeNode(char d){
treenode *T;
T = new treenode();
T->data = d;
T->lchild = NULL;
T->rchild = NULL;
return T;
}
treenode *expTree::getroot(){
return root;
}
void expTree::RInorderTraversal(treenode *T){
if (T != NULL){
RInorderTraversal(T->lchild);
cout << T->data << " ";
RInorderTraversal(T->rchild);
}
}
void expTree::RPreorderTraversal(treenode *T){
if (T != NULL){
cout << T->data << " ";
RPreorderTraversal(T->lchild);
RPreorderTraversal(T->rchild);
}
}
void expTree::RPostorderTraversal(treenode *T){
if (T != NULL){
RPostorderTraversal(T->lchild);
RPostorderTraversal(T->rchild);
cout << T->data << " ";
}
}
void expTree::NRInorderTraversal(treenode *T){
stack<treenode *> s;
treenode *curr = root;
while (curr != NULL || s.isempty() == false){
while (curr != NULL){
s.push(curr);
curr = curr->lchild;
}
curr = s.peek();
s.pop();
cout << curr->data << " ";
curr = curr->rchild;
 }
}
void expTree::NRPreorderTraversal(treenode *T){
if (root == NULL)
return;
stack<treenode *> s;
treenode *curr = root;
while (!s.isempty() || curr != NULL){
while (curr != NULL){
cout << curr->data << " ";
if (curr->rchild)
s.push(curr->rchild);
curr = curr->lchild;
}
if (s.isempty() == false){
curr = s.peek();
s.pop();
}
}
}
void expTree::NRPostorderTraversal(treenode *T){
if (root == NULL)
return;
stack<treenode *> s1, s2;
s1.push(root);
treenode *curr;
while (!s1.isempty()){
curr = s1.peek();
s1.pop();
s2.push(curr);
if (curr->lchild)
s1.push(curr->lchild);
if (curr->rchild)
s1.push(curr->rchild);
}
while (!s2.isempty()){
curr = s2.peek();
s2.pop();
cout << curr->data << " ";
}
}
int main(){
int choice;
string s;
cout << "\nEnter the postfix expression" << endl;
cin >> s;
expTree obj;
obj.createTree(s);
do{
cout << "\n====================================\n";
 cout << "Enter the choice of operation to be perfromed\n1.Recursive Inorder Traversal\n2.Recursive Preorder
Traversal\n3.Recursive Postorder Traversal\n4.Non-Recursive Inorder Traversal\n5.Non-Recursive Preorder Travseral\n6.Non-
Recursive Postorder Traversal\n7.Exit\n";
cin >> choice;
switch (choice){
case 1:obj.RInorderTraversal(obj.getroot());break;
case 2:obj.RPreorderTraversal(obj.getroot());break;
case 3:obj.RPostorderTraversal(obj.getroot());break;
case 4:obj.NRInorderTraversal(obj.getroot());break;
case 5:obj.NRPreorderTraversal(obj.getroot());break;
case 6:obj.NRPostorderTraversal(obj.getroot());break;
case 7:cout << "Exiting...";break;
default:cout << "Enter valid operation\n";
}
} while (choice != 7);
}

OUTPUT
Enter the postfix expression
abc*+

====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
1
a+b*c
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
2
+a*bc
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
3
abc*+
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
4
a+b*c
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
5
+a*bc
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
6
abc*+
====================================
Enter the choice of operation to be perfromed
1.Recursive Inorder Traversal
2.Recursive Preorder Traversal
3.Recursive Postorder Traversal
4.Non-Recursive Inorder Traversal
5.Non-Recursive Preorder Travseral
6.Non-Recursive Postorder Traversal
7.Exit
7
Exiting...