Static stack

#include<stdio.h>
#include<conio.h>
void push(int stack[100],int *top,int num,int max); //declaration of functions
int pop(int stack[10],int top);
void traverse(int stack[10],int top);
void push(int stack[100],int *top,int num,int max){ //function to push element in
stack
if(*top==max-1){
printf("\nOVERFLOW");
}
else{
*top=*top+1;
stack[*top]=num;
printf(“\nElement pushed in Stack : %d\n”,num);
}}
int pop(int stack[10],int top){ //function to pop element from stack
if(top==-1){
printf("\nUNDERFLOW");
}
else{
printf("Element Popped from Stack : %d",stack[top]);
top--;
}
return top;
}
void traverse(int stack[10],int top){ //function to traverse stack
int i;
if(top==-1){
printf("\nUNDERFLOW");
}
else{
printf("\n--------------STACK ELEMENTS-------------------------\n");
for(i=top;i>=0;i--)
{
printf("%d\t",stack[i]);
}
}}
void main(){ //main function
int stack[10],num,top,ch,max;
clrscr();
max=10;
top=-1;
for(;;)
{
printf("\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t---------------------MENU----------------------\t");
printf("\n1. Push an Element");
printf("\n2. Pop an Element");
printf("\n3. Traverse Stack");
printf("\n4. Exit");
printf("\n\nEnter your Choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
 printf("Enter the element you want to Push in Stack:");
scanf("%d",&num);
push(stack,&top,num,max);
break;
case 2:
top=pop(stack,top);
break;
case 3:
traverse(stack,top);
break;
case 4:
exit(0);
default:
printf("\nInvalid Choice");
}
getch();
}}

Dynamic Stack

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct stack //defining structure
{
int data;
struct stack *next;
};
void push(struct stack **top,int num); //declaring all functions
void pop(struct stack **top);
void traverse(struct stack *top);

void push(struct stack **top,int num){ //function to push element

struct stack *temp;
temp=(struct stack *)malloc(sizeof(struct stack));
temp->data=num;
temp->next=*top;
*top=temp;
printf("\nElement Pushed in Stack : %d\n",num);
}
void pop(struct stack **top){ //function to pop element
struct stack *temp;
if(*top==NULL){
printf("\nUNDERFLOW\n");
}
else{
temp=(*top);
printf("Element Popped from stack : %d\n",temp->data);
*top=(*top)->next;
free(temp);
}}
void traverse(struct stack *top){ //function to traverse
if(top==NULL){
printf("\nUNDERFLOW\n");
}
else{
printf("\n---------STACK ELEMENTS--------------\n");
while(top!=NULL)
{
printf("%d\t",top->data);
top=top->next;
}
}}
void main(){ //main function
struct stack *top;
int num,ch;
clrscr();
top=NULL;
for(;;)
{
printf("\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t---------------------MENU----------------------\t");
printf("\n1. Push an Element");
printf("\n2. Pop an Element");
printf("\n3. Traverse Stack");
printf("\n4. Exit");
printf("\n\nEnter your Choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("Enter the element you want to Push in Stack:");
scanf("%d",&num);
 push(&top,num);
break;
case 2:
pop(&top);
break;
case 3:
traverse(top);
break;
case 4:
exit(0);
default:
printf("\nInvalid Choice");
}
getch();
}}

Static Circular Queue

#include<stdio.h>
#include<conio.h>
void insert(int cqueue[10],int *front,int *rear,int num,int max); //declaration
void delete(int cqueue[10],int *front,int *rear,int max);
void traverse(int cqueue[10],int front,int rear);
void insert(int cqueue[10],int *front,int *rear,int num,int max){ //insert element
if(*rear==-1){
*front=0;
*rear=0;
 cqueue[*rear]=num;
printf("\nElement inserted : %d\n",num);
}
else if((*front==0 && *rear==max-1) || (*front==*rear+1)){
printf("\nOVERFLOW\n");
}
else{
if(*rear==max-1)
{
*rear=0;
}
else
{
*rear=*rear+1;
}
cqueue[*rear]=num;
printf("\nElement Inserted : %d",num);
}
}
void delete(int cqueue[10],int *front,int *rear,int max){ //delete element
if(*front==-1){
printf("\nUNDERFLOW\n");
}
else if(*front==*rear){
printf("\nDeleted Element : %d",cqueue[*front]);
*front=-1;
*rear=-1;
}
else{
if(*front==max-1)
{
printf("\nElement Deleted : %d",cqueue[*front]);
*front=0;
}
else
{
printf("\nElement Deleted : %d",cqueue[*front]);
*front=*front+1;
}
}}
void traverse(int cqueue[10],int front,int rear){ //traverse circular queue
int i;
if ((front==-1) || (front==rear+1)){
printf("\nUNDERFLOW\n");
}
else{
printf("\n----------Queue Elements-------------\n");
for(i=front;i<=rear;i++)
{
printf("%d\t",cqueue[i]);
}
}}
void main(){ //main function
int cqueue[10],max,front,rear,ch,num;
clrscr();
max=10;
front=rear=-1;
for(;;)
{
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t---------------------MENU----------------------\t");
printf("\n1. Insert an Element");
printf("\n2. Delete an Element");
printf("\n3. Traverse Queue");
printf("\n4. Exit");
printf("\n\nEnter your Choice:");
scanf("%d",&ch);

switch(ch)
{
case 1:
printf("\nEnter the number you want to insert in Queue:");
scanf("%d",&num);
insert(cqueue,&front,&rear,num,max);
break;
case 2:
delete(cqueue,&front,&rear,max);
break;
case 3:
traverse(cqueue,front,rear);
break;
case 4:
exit(0);
default:
 printf("\nInvalid Choice");
}
getch();
}}

Dynamic Circular Queue

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

struct cqueue
{
int data;
struct cqueue *next;
};
void insert(struct cqueue **front,struct cqueue **rear,int num); //declaration of
function
void delete(struct cqueue **front,struct cqueue **rear);
void traverse(struct cqueue *front);
void insert(struct cqueue **front,struct cqueue **rear,int num){ //insert element
if(*rear==NULL){
*rear=(struct cqueue *)malloc(sizeof(struct cqueue));
*front=*rear;
}
else{
(*rear)->next=(struct cqueue *)malloc(sizeof(struct cqueue));
(*rear)=(*rear)->next;
}
(*rear)->data=num;
(*rear)->next=*front;
printf("\nElement Inserted in Queue : %d",num);
}
void delete(struct cqueue **front,struct cqueue **rear){ //delete element
struct cqueue *temp;
if(*front==NULL){
printf("UNDERFLOW\n");
}
else{
if(*front==*rear)
{
printf("\nElement Deleted : %d",(*front)->data);
free(*front);
*front=NULL;
*rear=NULL;
}
else
{
temp=*front;
printf("\nElement Deleted : %d",temp->data);
*front=(*front)->next;
(*rear)->next=*front;
free(temp);
}
}}
void traverse(struct cqueue *front){ //function to traverse circular
queue
struct cqueue *temp=front;
if(front==NULL){
printf("\nUNDERFLOW\n");
}
else{
while(temp->next!=front)
{
printf("%d\t",temp->data);
temp=temp->next;
}
printf("%d\t",temp->data);
}}
void main(){ //main function
struct cqueue *front,*rear;
int num,ch;
clrscr();
front=rear=NULL;
for(;;){
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t---------------------MENU----------------------\t");
printf("\n1. Insert an Element");
printf("\n2. Delete an Element");
printf("\n3. Traverse Queue");
printf("\n4. Exit");
printf("\n\nEnter your Choice:");
scanf("%d",&ch);

switch(ch)
 {
case 1:
printf("\nEnter the element you want to insert in queue:");
scanf("%d",&num);
insert(&front,&rear,num);
break;
case 2:
delete(&front,&rear);
break;
case 3:
traverse(front);
break;
case 4:
exit(0);
default:
printf("\nInvalid Choice");
}
getch();
}}

Static Dequeue
#include<stdio.h>
#include<conio.h>
#define MAX 10
void insert_rear(int dequeue[MAX],int *front,int *rear,int num); //declaration
void insert_front(int dequeue[MAX],int *front,int num);
void delete_front(int dequeue[MAX],int *front,int *rear);
void delete_rear(int dequeue[MAX],int *front,int *rear);
void display(int dequeue[MAX],int front,int rear);
void insert_rear(int dequeue[MAX],int *front,int *rear,int num){ //insert element at
rear
if(*rear==MAX-1){
printf("\nQueue is Overflow\n");
}
else{
if(*front==-1 && *rear==-1)
{
*front=0;
*rear=0;
}
else
{
*rear=*rear+1;
}
dequeue[*rear]=num;
printf("\nElement inserted : %d",num);
}}
void insert_front(int dequeue[MAX],int *front,int num){ //insert element at
front
if(*front<=0){
printf("\nCannot add value at front\n");
}
else{
*front=*front-1;
dequeue[*front]=num;
printf("\nElement inserted : %d",num);
}}
void delete_front(int dequeue[MAX],int *front,int *rear){ //delete element from
front
if(*front==-1){
printf("\nQueue is UNDERFLOW\n");
}
else{
if(*front==*rear)
{
printf("\nElement deleted : %d",dequeue[*front]);
*front=-1;
*rear=-1;
}
else
{
printf("\nElement deleted : %d",dequeue[*front]);
*front=*front+1;
}
}}
void delete_rear(int dequeue[MAX],int *front,int *rear){ //delete element from
rear
if(*rear==-1){
printf("\nQueue is UNDERFLOW\n");
}
else{
if(*rear==*front)
{
printf("\nElement deleted : %d",dequeue[*rear]);
 *rear=-1;
*front=-1;
}
else
{
printf("\nElement deleted : %d",dequeue[*rear]);
*rear=*rear-1;
}
}}
void display(int dequeue[MAX],int front,int rear){ //display all elements
int i;
if(front==-1){
printf("\nQueue is UNDERFLOW\n");
}
else{
printf("\n----------Queue Elements----------------\n");
for(i=front;i<=rear;i++)
{
printf("%d\t",dequeue[i]);
}
}}
void main(){ //main function
int ch,dequeue[MAX],rear,front,num;
front=rear=-1;
clrscr();
for(;;){
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t\t------------MENU------------------\n");
printf("\n1. Insert at front");
printf("\n2. Insert at rear");
printf("\n3. Delete at front");
printf("\n4. Delete at rear");
printf("\n5. Traverse");
printf("\n6. Exit");
printf("\n\nEnter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("\nEnter the element you want to insert:");
scanf("%d",&num);
insert_front(dequeue,&front,num);
break;
case 2:
printf("\nEnter the element you want to insert:");
scanf("%d",&num);
insert_rear(dequeue,&front,&rear,num);
break;
case 3:
delete_front(dequeue,&front,&rear);
break;
case 4:
delete_rear(dequeue,&front,&rear);
break;
case 5:
display(dequeue,front,rear);
 break;
case 6:
exit(0);
default:
printf("\nInvalid choice\n");
}
getch();
}}

Dynamic Dequeue
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

struct dequeue
{
struct dequeue *previous;
int data;
struct dequeue *next;
};
void addatbeg(struct dequeue **front,struct dequeue **rear,int num); //declaration
void addatend(struct dequeue **front,struct dequeue **rear,int num);
void delete_front(struct dequeue **front,struct dequeue **rear);
void delete_rear(struct dequeue **front,struct dequeue **rear);
void traverse(struct dequeue *front);
void addatbeg(struct dequeue **front,struct dequeue **rear,int num){
struct dequeue *temp;
if(*front==NULL){
*front=(struct dequeue *)malloc(sizeof(struct dequeue));
(*front)->data=num;
(*front)->previous=NULL; //function to add element at front
(*front)->next=NULL;
*rear=*front;
}
else{
temp=(struct dequeue *)malloc(sizeof(struct dequeue));
temp->data=num;
temp->previous=NULL;
temp->next=*front;
(*front)->previous=temp;
*front=temp;
}
printf("\nElement inserted : %d",num);
}
void addatend(struct dequeue **front,struct dequeue **rear,int num){
if(*rear==NULL){
*rear=(struct dequeue *)malloc(sizeof(struct dequeue));
(*rear)->previous=NULL;
(*rear)->data=num; //function to add element at end
(*rear)->next=NULL;
*front=*rear;
}
else{
(*rear)->next=(struct dequeue *)malloc(sizeof(struct dequeue));
 (*rear)->next->previous=*rear;
(*rear)->next->data=num;
(*rear)->next->next=NULL;
*rear=(*rear)->next;
}
printf("\nElement inserted : %d",num);
}
void delete_front(struct dequeue **front,struct dequeue **rear){
struct dequeue *temp;
if(*front==NULL){
printf("\nQueue is UNDERFLOW\n");
} //function to delete element from front
else{
temp=*front;
*front=(*front)->next;
(*front)->previous=NULL;
printf("\nElement deleted : %d",temp->data);
free(temp);
if(*front==NULL)
{
*rear=NULL;
}
}}
void delete_rear(struct dequeue **front,struct dequeue **rear){
struct dequeue *temp;
if(*rear==NULL){
printf("\nQueue is underflow\n"); //function to delete element from
rear
}
else{
temp=*rear;
*rear=(*rear)->previous;
(*rear)->next=NULL;
printf("\nElement deleted : %d",temp->data);
free(temp);
if(*rear==NULL)
{
*front=NULL;
}
}}
void traverse(struct dequeue *front){ //function to traverse queue
if(front==NULL){
printf("\nQueue is UNDERFLOW\n");
}
else{
printf("\n----------Queue Elements-----------------\n");
while(front!=NULL)
{
printf("%d\t",front->data);
front=front->next;
}
}}
void main(){ //main function for menu
int ch,num;
struct dequeue *front,*rear;
front=rear=NULL;
clrscr();
for(;;){
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\n\t\t\t------------MENU------------------\n");
printf("\n1. Insert at front");
printf("\n2. Insert at rear");
printf("\n3. Delete at front");
printf("\n4. Delete at rear");
printf("\n5. Traverse");
printf("\n6. Exit");
printf("\n\nEnter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:
printf("\nEnter the element you want to insert:");
scanf("%d",&num);
addatbeg(&front,&rear,num);
break;
case 2:
printf("\nEnter the element you want to insert:");
scanf("%d",&num);
addatend(&front,&rear,num);
break;
case 3:
delete_front(&front,&rear);
break;
case 4:
delete_rear(&front,&rear);
 break;
case 5:
traverse(front);
break;
case 6:
exit(0);
default:
printf("\nInvalid choice\n");
}
getch();
}}

Infix to Prefix Expression

//prefix conversion
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define MAX 50
struct infix{
char stack[MAX];
char target[MAX];
char *s,*t;
int top;
};
void intinfix(struct infix *p);
void setexpr(struct infix *p,char *expr);
void push(struct infix *p,char c);
char pop(struct infix *p);
int priority(char c);
void convert(struct infix *p);
void intinfix(struct infix *p){
p->top=-1;
strcpy(p->target,"");
strcpy(p->stack,"");
p->t=p->target;
p->s="";
}
void setexpr(struct infix *p,char *expr){
p->s=expr;
}
void push(struct infix *p,char c){ //function to push operators from stack
if(p->top==MAX-1){
printf("\nStack is Full\n");
}
else{
p->top++;
p->stack[p->top]=c;
}
}
char pop(struct infix *p){ //function to pop operators from stack
char item;
if(p->top==-1){
 //stack is empty
return -1;
}
else{
item=p->stack[p->top];
p->top--;
return item;
}}
int priority(char c){
if(c=='$' || c=='^')
{
return 3;
}
else if(c=='/' || c=='*' || c=='%')
{
return 2;
}
else if(c=='+' || c=='-')
{
return 1;
}
else
{
return 0;
}
}
void convert(struct infix *p){ //function to convert
char opr;
while(*(p->s)!='\0'){
if(*(p->s)==' ' || *(p->s)=='\t')
{
p->s++;
}
else if(*(p->s)==')')
{
push(p,*(p->s));
p->s++;
}
else if(isdigit (*(p->s)) || isalpha (*(p->s)))
{
*(p->t)=*(p->s);
p->t++;
p->s++;
}
else if(*(p->s)=='(')
{
opr=pop(p);
while(opr!=')')
{
*(p->t)=opr;
p->t++;
opr=pop(p);
}
p->s++;
}
else if(*(p->s)=='*' || *(p->s)=='+' || *(p->s)=='-' || *(p->s)=='/' || *(p->s)=='$' || *(p-
>s)=='^')
 {
if(p->top!=-1)
{
opr=pop(p);
while(priority(opr)>priority(*(p->s)))
{
*(p->t)=opr;
p->t++;
opr=pop(p);
}
push(p,opr);
push(p,*(p->s));
}
else
{
push(p,*(p->s));
}
p->s++;
}
}
while(p->top!=-1){
opr=pop(p);
*(p->t)=opr;
p->t++;
}
*(p->t)='\0';
}
void main() //main function
{
struct infix p;
char expr[MAX],temp[MAX],prefix[MAX];
int i,j,k;
intinfix(&p);
clrscr();
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\nEnter an expression in infix form:");
gets(expr);
strrev(expr);
setexpr(&p,expr);
convert(&p);
printf("\n\n------------Prefix Expression--------------\n\n");
strrev(p.target);
printf("%s",p.target);
getch();
}

Infix to Postfix expression

//postfix expression

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define MAX 50
struct infix{
char stack[MAX];
char target[MAX];
char *s,*t;
int top;
};
void intinfix(struct infix *p); //declaring all function
void setexpr(struct infix *p,char *expr);
void push(struct infix *p,char c);
char pop(struct infix *p);
int priority(char c);
void convert(struct infix *p);
void intinfix(struct infix *p){
p->top=-1;
strcpy(p->target,"");
strcpy(p->stack,"");
p->t=p->target;
p->s="";
}
void setexpr(struct infix *p,char *expr){
p->s=expr;
}
void push(struct infix *p,char c){ //function to push operators in
stack
if(p->top==MAX-1){
printf("\nStack is Full\n");
}
else{
p->top++;
 p->stack[p->top]=c;
}}
char pop(struct infix *p){ //function to pop operators from stack
char item;
if(p->top==-1){
//Stack is Empty
return -1;
}
else{
item=p->stack[p->top];
p->top--;
return item;
}}
int priority(char c){ //function to get priority of operators
if(c=='$' || c=='^')
{
return 3;
}
else if(c=='/' || c=='*' || c=='%')
{
return 2;
}
else if(c=='+' || c=='-')
{
return 1;
}
else
{
 return 0;
}
}
void convert(struct infix *p){ //function to convert
char opr;
while(*(p->s)!='\0'){
if(*(p->s)==' ' || *(p->s)=='\t')
{
p->s++;
}
else if(*(p->s)=='(')
{
push(p,*(p->s));
p->s++;
}
else if(isdigit (*(p->s)) || isalpha (*(p->s)))
{
*(p->t)=*(p->s);
p->t++;
p->s++;
}
else if(*(p->s)==')')
{
opr=pop(p);
while(opr!='(')
{
*(p->t)=opr;
p->t++;
 opr=pop(p);
}
p->s++;
}
else if(*(p->s)=='*' || *(p->s)=='+' || *(p->s)=='-' || *(p->s)=='/' || *(p->s)=='$' || *(p-
>s)=='^')
{
if(p->top!=-1)
{
opr=pop(p);
while(priority(opr)>=priority(*(p->s)))
{
*(p->t)=opr;
p->t++;
opr=pop(p);
}
push(p,opr);
push(p,*(p->s));
}
else
{
push(p,*(p->s));
}
p->s++;
}
}
while(p->top!=-1){
opr=pop(p);
*(p->t)=opr;
 p->t++;
}
*(p->t)='\0';
}
void main(){ //main function
struct infix p;
char expr[MAX];
intinfix(&p);
clrscr();
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\nEnter an expression in infix form:");
gets(expr);
setexpr(&p,expr);
convert(&p);
printf("\n\n-------------Postfix Expression-------------\n\n");
printf("%s",p.target);
getch();
}

Prefix Expression

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<ctype.h>
#define MAX 50
struct prefix{
int stack[MAX];
int top,result;
char *s;
}; //declaring all functions
void inprefix(struct prefix *p);
void setexpr(struct prefix *p,char *expr);
void push(struct prefix *p,int num);
int pop(struct prefix *p);
void calculate(struct prefix *p);
void inprefix(struct prefix *p){
p->top=-1;
}
void setexpr(struct prefix *p,char *expr){
p->s=expr;
}
void push(struct prefix *p,int num){ //function to push numbers
if(p->top==MAX-1){
printf("\nStack is Full\n");
}
else{
p->top++;
p->stack[p->top]=num;
}}
int pop(struct prefix *p){ //function to pop numbers
int data;
if(p->top==-1){
 printf("\nStack is empty\n");
return NULL;
}
else{
data=p->stack[p->top];
p->top--;
return data;
}}
void calculate(struct prefix *p){ //function to evaluate prefix expression

int n1,n2,n3;
while(*(p->s)!='\0'){
if(*(p->s)==' ' || *(p->s)=='\t')
{
p->s++;
}
else if(isdigit(*(p->s)))
{
p->result=*(p->s)-'0';
push(p,p->result);
p->s++;
}
else
{
n1=pop(p);
n2=pop(p);
switch(*(p->s))
{
case '+':
 n3=n1+n2;
break;
case '-':
n3=n1-n2;
break;
case '*':
n3=n1*n2;
break;
case '/':
n3=n1/n2;
break;
case '%':
n3=n1%n2;
break;
case '$':
n3=pow(n1,n2);
break;
default:
printf("\nUnknown Operator\n");
exit(1);
}
push(p,n3);
p->s++;
}
}}
void main(){ //main function
struct prefix p;
char expr[MAX];
clrscr();
inprefix(&p);
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");
printf("\nEnter the expression in prefix form:");
gets(expr);
strrev(expr);
setexpr(&p,expr);
calculate(&p);
p.result=pop(&p);
printf("\nResult of Prefix expression : %d",p.result);
getch();
}

Postfix Expression
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<ctype.h>
#define MAX 50
struct postfix{
int stack[MAX];
int top,result;
char *s;
};
void postinfix(struct postfix *p); //declaring all functions
void setexpr(struct postfix *p,char *expr);
void push(struct postfix *p,int num);
int pop(struct postfix *p);
void calculate(struct postfix *p);
void postinfix(struct postfix *p){
p->top=-1;
}
void setexpr(struct postfix *p,char *expr){ //function to set expression
p->s=expr;
}
void push(struct postfix *p,int num){ //function to push numbers in stack
if(p->top==MAX-1){
printf("\nStack is Full\n");
}
else{
p->top++;
p->stack[p->top]=num;
}}
int pop(struct postfix *p){ //function to pop numbers from stack
int data;
if(p->top==-1){
printf("\nStack is empty\n");
return NULL;
}
else{
data=p->stack[p->top];
p->top--;
 return data;
}}
void calculate(struct postfix *p){ //function to evaluate
expression
int n1,n2,n3;
char temp;
while(*(p->s)!='\0'){
if(*(p->s)==' ' || *(p->s)=='\t')
{
p->s++;
}
else if(isdigit(*(p->s)))
{
p->result=*(p->s)-'0';
push(p,p->result);
p->s++;
}
else
{
n2=pop(p);
n1=pop(p);

switch(*(p->s))
{
case '+':
n3=n1+n2;
break;
case '-':
n3=n1-n2;
 break;
case '*':
n3=n1*n2;
break;
case '/':
n3=n1/n2;
break;
case '%':
n3=n1%n2;
break;
case '$':
n3=pow(n1,n2);
break;
default:
printf("\nUnknown Operator\n");
exit(1);
}
push(p,n3);
p->s++;
}
}}
void main(){ //main function
char expr[MAX];
struct postfix p;
clrscr();
printf("\n\t\tName : Shiv Yadav\t\tEnrol no: 03614202021\n");

postinfix(&p);
printf("\nEnter the expression in postfix form:");
gets(expr);
setexpr(&p,expr);
calculate(&p);
p.result=pop(&p);
printf("\nThe result of Postfix expression = %d",p.result);
getch();
}