Stack prgs

1. 1)‘C’ Program
/************************************************************
Program for implementing a stack using arrays.It involves
various operations such as push,pop,stack empty,stack full and
display.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
int s[size];
int top;
}st;
/*
The stfull Function
Input:none
Output:returns 1 or 0 for stack full or not
Called By:main
Calls:none
*/
int stfull()
{
if(st.top>=size-1)
return 1;
else
return 0;
}
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(int item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;

2. }
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
int pop()
{
int item;
item=st.s[st.top];
st.top – –;
return(item);
}
/*
The display Function
Input:none
Output:none-displys the contents of the stack
Called By:main
Calls:none
*/
void display()
{
int i;
if(stempty())
printf(―n Stack Is Empty!‖);
else
{
for(i=st.top;i>=0;i– –)
printf(―n%d‖,st.s[i]);
}
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty,stfull,display
*/
void main(void)
{
int item,choice;
char ans;
st.top=-1;
clrscr();
printf(―ntt Implementation Of Stack‖);
do
{
printf(―n Main Menu‖);
printf(―n1.Pushn2.Popn3.Displayn4.exit‖);
printf(―n Enter Your Choice‖);
scanf(―%d‖,&choice);
switch(choice)

3. {
case 1:printf(―n Enter The item to be pushed‖);
scanf(―%d‖,&item);
if(stfull())
printf(―n Stack is Full!‖);
else
push(item);
break;
case 2:if(stempty())
printf(―n Empty stack!Underflow !!‖);
else
{
item=pop();
printf(―n The popped element is %d‖,item);
}
break;
case 3:display();
break;
case 4:exit(0);
}
printf(―n Do You want To Continue?‖);
ans=getche();
}while(ans ==‘Y‘ ||ans ==‘y‘);
getch();
}
/******************** End Of Program ************************/
2)‘C’ Program
/************************************************************
Program to evaluate a given postfix expression. The program
handles postfix expressions with only binary arithmatic
operators +,-,*,/ and ^. Operands are single digit numbers
between 0-9.
*************************************************************/
/* List of include files */
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
/* List of defined constants */
#define size 80
/* Global declarations */
struct stack
{ double s[size];
int top;
}st;
enum Type { operand, oprtor };
/* The Push function
Input : A value to be pushed on global stack
Output: None, modifies global stack and its top
Parameter Passing Method :By Value
Called By : Post()

4. Calls :none
*/
void Push(double Val)
{
if ( st.top+1 >= size )
printf(―Error: Stack is Fulln‖);
st.top++;
st.s[st.top] = Val;
}
/* The Pop function
Input : None, uses global stack and top
Output: Returns the value on top of stack
Parameter Passing Method :None
Called By : post()
Calls :none
*/
double Pop()
{
double Val;
if ( st.top == -1 )
printf(―Error: Stack is Emptyn‖);
Val = st.s[st.top];
st.top—;
return(Val);
}
/* The gettokn function
Input : Given infix expression
Output: Returns the next character from the expression
Parameter Passing Method : By reference
Called By : post()
Calls : None
*/
char gettokn( char exp[])
{
static int i = 0;
char ch;
ch = exp[i];
i++;
return ch;
}
/* The Gettype function
Input : A character from infix expression
Output: Returns the token type as operand or oprtor
Parameter Passing Method : By value
Called by : post()
Calls : none
*/
enum Type Gettype(char ch)
{
ch = toupper(ch); /* convert to upper case */
if ( ch >= ‗0‘ && ch <= ‗9‘)
return operand;
if ( ch == ‗+‘|| ch == ‗-‘||
ch == ‗*‘|| ch == ‗/‘ ||

5. ch == ‗^‘ )
return oprtor;
/* Error */
printf(―Invalid operatorn‖);
}
/* The post function which contains major logic of
the program.
Input : A post Expression of single digit operand
Output: Resultant value after evaluating the expression
Parameter Passing Method :by reference
Called By : main()
Calls :gettoken(), Push(), Pop() and
Gettype()
*/
double post( char exp[])
{
char ch,type;
double result, Val, Op1, Op2;
st.top = 0;
ch = gettokn(exp);
while ( ch != ‗$‘ )
{
type = Gettype(ch);
if( type ==operand)
{
Val = ch - 48;
Push( Val);
}
else
if ( type == oprtor)
{
Op2 = Pop();
Op1 = Pop();
switch(ch)
{
case ‗+‘ : result = OP1 + Op2;
break;
case ‗–‘ : result = Op1 – Op2;
break;
case ‗*‘ : result = Op1 * Op2;
break;
case ‗/‘ : result = Op1 / Op2;
break;
case ‗^‘ : result = pow (Op1 – Op2;
break;
}/* switch */
Push (result);
}
ch = gettokn(exp);
}/* while */
result = Pop();
return(result);
}
/* The main function

6. Input : None
Output : None
Parameter Passing Method : None
called By : OS
Calls : post()
*/
void main ()
{
/* Local declarations */
char exp[size];
int len;
double Result;
clrscr();
printf(―‖Enter the postfix Expressionn");
scanf(―%S‖,exp);
len = strlen(exp);
exp[len] = ‗‘; /* Append at the end */
Result = post(exp);
printf(―The Value of the expression is %fn‖, Result);
getch();
exit(0);
}
/ ************** End of the Program ***************** /
3) ‘C’ Program
/ **********************************************************
Program for conversion of Infix expression to Postfix form.
************************************************************/
#include<stdio.h>
#include<conio.h>
#include<alloc.h>
char inf[40],post[40];
int top=0,st[20];
void postfix();
void push(int);
char pop();
/*
The main Function
Input:none
Output:none
Called BY:O.S.
Calls:postfix
*/
void main(void)
{
clrscr();
printf(―ntEnter the infix expression :: nntt‖);
scanf(―%s‖, inf);
postfix();
getch();
}
/*
The postfix Function
Input:none
Output:none

7. Called By:main
Calls:push,pop
*/
void postfix()
{
int i,j=0;
for(i=0;inf[i]!=‘0‘;i++)
{
switch(inf[i])
{
case ‗+‘ : while(st[top] > = 1)
post[j++] = pop();
push(1)
break;
case ‗–‘ : while(st[top] >=1)
post[j++] = pop();
push(2);
break;
case ‗*‘ : while(st[top] >=3)
pos[j++] = pop();
push(3)
break;
case ‗/‘ : while(st[top] > = 3)
post[j++] = pop();
push(4);
break;
case ‗^‘ : while(st[top] >=4)
post[j++] = pop();
push(5);
break;
case ‗(‗ : push(0);
break;
case ‗)‘ : while(st[top] ! = 0
post[j++] = pop();
top —;
break;
default : post[j++] = inf[i];
}
}
while(top>0)
post[j++] = pop();
print(―ntPostfix expression is = > nntt %s‖, post);
}
/*
The push Function
Input:ele-the element which is to be pushed onto the stack
Output:none
Called By:postfix
Calls:none
*/
void push(int ele)
{
top++;
st[top] = ele;

8. }
/*
The pop Function
Input:none
Output:e-the popped element
Called By:postfix
Calls:none
*/
char pop()
{
int el;
char e;
el = st[top];
top—;
switch(el)
{
case 1 : e = ‗+‘;
break;
case 2 : e = ‗–‘;
break;
case 3 : e = ‗*‘;
break;
case 4 : e = ‗/‘;
break;
case 5 : e = ‗^‘;
break;
}
return(e);
}
/**************** end of program ********************/
4)C Program
/************************************************************
Program for checking the well formedness of the parenthesis.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
char s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(char item)
{

9. st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
char pop()
{
char item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)
{
char item;
char ans,bracket[10];
int i;
st.top=-1;
clrscr();
printf(―ntt Enter The expression and put $ at the end‖);
scanf(―%s‖,bracket);
i=0;
if(bracket[i]==‘)‘)
printf(―n The expression is invalid‖);
else
{
do
{

10. while(bracket[i]==‘(‗)
{
push(bracket[i]);
i++;
}
while(bracket[i]==‘)‘)
{
item=pop();
i++;
}
}while(bracket[i]!=‘$‘);
if(!stempty())
printf(―n The expression is invalid‖);
else
printf(―n The expression has well formed parenthesis‖);
}
getch();
}
5)C Program
/*************************************************************
Program for converting decimal number to binary number
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
int s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(int item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{

11. if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
int pop()
{
int item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)
{
int item,i,num;
st.top=-1;
clrscr();
printf(―n Program For Decimal TO Binary Conversion‖);
printf(―ntt Enter The number‖);
scanf(―%d‖,&num);
while(num>=1)
{
item=num%2;
push(item);
num=num/2
}
while(!stempty())
printf("%d",pop());
getch();
}
6)C Program
/*************************************************************
Program for reversing the given string using stack
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#define size 10

12. /* stack structure*/
struct stack {
char s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(char item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
char pop()
{
char item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)

13. {
char item,string[10];
int i;
st.top=-1;
clrscr();
printf(―n Program For reversing a given string‖);
printf(―ntt Enter The string:‖);
scanf(―%s‖,&string);
i=0;
while(string[i]!=‘0‘)
{
push(string[i]);
i++;
}
printf(―ttt‖);
while(!stempty())
{
item=pop();
printf(―%c‖,item);
}
getch();
}
7)‘C’ Program
/*************************************************************
Program to implement multiple stacks using single array
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 20
int stack[MAX];
int size[MAX],lb,ub;
/* set_stack Function
It is for defining the upper limit and lower limit of each stack
Input:the index,which indicates the stack number
Output:none,It sets the upper and lower boundries of the stack
Called By:stempty,stfull,display,display_all
Calls:none
Parameter passing method:By value
*/
void set_stack(int index)
{
int sum,i;
if(index==1)
{
lb=1;
ub=size[index];
}
else
{
sum=0;
for(i=1;i<index;i++)
sum=sum+size[i];

14. lb=sum+1;
ub=sum+size[index];
}
}
/* stfull Function
It checks whether the stack is full or not
Input:the index,which indicates the stack number
Output:1 if stack is full otherwise 0
Called By:main
Calls:set_stack
Parameter passing method:By value
*/
int stfull(int index)
{
int top,i,sum;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]==-1)
break;
}
if(top-1==ub)
return 1;
else
return 0;
}
/* stempty Function
It checks whether the stack is empty or not
Input:the index,which indicates the stack number
Output:1 if stack is empty otherwise 0
Called By:main
Calls:set_stack
Parameter passing method:By value
*/
int stempty(int index)
{
int top;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
return 0;
return 1;
}
}
/* push Function
Input:the item which is to be pushed onto the stack
Output:none
Called By:main
Calls:
Parameter passing method:By value
*/
void push(int item)
{

15. int top;
for(top=lb;top<=ub;top++)
if(stack[top]==-1)
break;
stack[top]=item;
return;
}
/* pop Function
It pops the element from desired stack
Input:none
Output:item,popped element
Called By:main
Calls:none
*/
int pop()
{
int top,item;;
for(top=lb;top<=ub;top++)
if(stack[top]==-1)
break;
top—;
item=stack[top];
stack[top]=-1;
return item;
}
/* display Function
It displays only desired stack
Input:the index,which indicates the stack number
Output:none
Called By: main
Calls:set_stack
Parameter passing method:By value
*/
void display(int index)
{
int top;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
printf(―%d‖,stack[top]);
}
}
/* display_all Function
It displays all the stacks in the array
Input:the n,which indicates total number of stacks
Output:none
Called By:main
Calls:set_stack
Parameter passing method:By value
*/void display_all(int n)
{
int top,index;

16. for(index=1;index<=n;index++)
{
printf(―nstack number %d is‖,index);
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
printf(― %d‖,stack[top]);
}
}
}
/* main Function
Input:none
Output:none
Called By:O.S.
Calls:stfull,push,stempty,pop,display,display_all
Parameter passing method:
*/
void main(void)
{
int n,index,i,item,choice;
char ans;
clrscr();
ans=‘y‘;
for(i=1;i<=MAX;i++)
stack[i]=-1;/*for initialization of the entire array of stacks*/
printf(―nt Program For multiple stacks using single array‖);
printf(―n Enter how many stacks are there‖);
scanf(―%d‖,&n);
printf(―n Enter the size for each stack‖);
for(i=1;i<=n;i++)
{
printf(―n size for stack %d is‖,i);
scanf(― %d‖,&size[i]);
}
do
{
printf(―ntt Main Menu‖);
printf(―n 1.Push n2.Pop n3.Display n4.Dispaly all‖);
printf(―n Enter Your choice‖);
scanf(―%d‖,&choice);
switch(choice)
{
case 1:printf(―n Enter the item to be pushed‖);
scanf(―%d‖,&item);
printf(―n In Which stack?‖);
scanf(―%d‖,&index);
if(stfull(index))
printf(―n Stack %d is Full,can not Push‖,index);
else
push(item);
break;
case 2:printf(―n From Which stack?‖);
scanf(―%d‖,&index);

17. if(stempty(index))
printf(―n Stack number %d is empty!‖,index);
else
{
item=pop();
printf(―n %d is popped from stack %d‖,item,index);
}
break;
case 3:printf(―n Which stack has to be displayed?‖);
scanf(―%d‖,&index);
display(index);
break;
case 4:display_all(n);
break;
default:printf(―n Exitting‖);
}
printf(―n Do you wish to continue?‖);
ans=getch();
}while(ans==‘y‘||ans==‘Y‘);
getch();
}
/********************* End Of Program**********************/
8)C Program
/*******************************************************************************************
Program for finding out the factorial for any given number.
*************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* The fact function
Input:the numer n
Output: factorial of n
Called By:main
Calls:itself
*/
int fact(int n)
{
int x,y;
if(n<0)
{
printf(―The negative parameter in the factorial function‖);
exit(0);
}
if(n==0)
return 1;
x=n-1;
y=fact(x);
return(n*y);
}
/* The main function
Input:none
Output:none
Called By:O.S.

18. Calls:fact
*/
void main(void)
{
int n,f;
clrscr();
printf(―ntt Program For finding the factorial of n‖);
printf(―nn Enter the number for finding the factorial‖);
scanf(―%d‖,&n);
f=fact(n);
printf(―n the factorial of %d is %d‖,n,f);
getch();
}
/********************** End Of Program **********************/
9)C Program
/*************************************************************
Program for computing the number in the fibonacci series at
certain location.For e.g.the sixth number in fibonacci series
will be 8.The fibonacci series is 1 1 2 3 5 8 13 21 34...
*************************************************************/
/*header files*/
#include<stdio.h>
#include<conio.h>
/*
The fib Function.
Input:the location n.
Output:the value at that location in fibonacci series.
Called By:main.
Calls:itself.
*/
int fib(int n)
{
int x,y;
if(n<=1)
return n;
x=fib(n-1);
y=fib(n-2);
return (x+y);
}
/*
The main function
Input:none
Output:none
Called By:o.s
Calls:fib-the fibonacci function.
*/
void main(void)
{
int n,num;
clrscr();
printf(―n Enter location in fibonacci series‖);
scanf(―%d‖,&n);
num=fib(n);
printf(―n The number at %dth position is %d in fibonacci

19. series‖,n,num);
getch();
}
/********************** End of Program ***********************/
10)C Program
/*************************************************************
Program for Multiplication Of natural numbers.The multiplication
two numbers is considerd.This is program uses the recurssive
definition.
*************************************************************/
/*header files*/
#include<stdio.h>
#include<conio.h>
/*************************************************************
mul Function
Input:two numbers a,b
Output:returns the multiplication result
Called by:main
Calls:mul i.e.itself
*************************************************************/
mul(int a,int b)
{
if(b==1)
return a;
else
return(mul(a,b-1)+ a);
}
/*************************************************************
main Function
Input:none
Output:none
Called by:O.S.
Calls:mul
*************************************************************/
main()
{
int a,b,result=0;
clrscr();
printf(―n Enter the values of a and b‖);
scanf(―%d%d‖,&a,&b);
result=mul(a,b);
printf(―The multiplication is =%d‖,result);
getch();
}
11)C Program
/*************************************************************
Program to find out the greatest common divisor of the two
integers.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int gcd(int a,int b)
{

20. int temp,ans;
if(b<=a &&a%b ==0)
return b;
else
{
if(b<a)
{
temp = a;
a = b; /*interchanging the a and b values*/
b = temp;
}
ans = a%b;
return(gcd(b,ans));
}
}
void main(void)
{
int a,b,ans;
clrscr();
printf(―ntt GCD Of two integers‖);
printf(―nn Enter the two numbers‖);
scanf(―%d %d‖,&a,&b);
ans=gcd(a,b);
printf(―n The gcd of %d and %d is = %d‖,a,b,ans);
getch();
}
/********************** End of program *******************/
12)C Program
/*******************************************************************
Conversion of postfix expression to infix form
*******************************************************************/
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<process.h>
typedef struct node
{
char str[25];
}node;
node stack[20];
int top = –1;
char input[100];
void post2in();
void push(char *op)
{
if(top == 20)
{
printf("nStack full");
exit(0);
}
top++;

21. strcpy(stack[top].str,op);
}
char *pop()
{
char *op;
op=(char *)malloc(25);
if(top==–1)
{
printf("ntlllegal expression : operand missing");
exit(0);
}
strcpy(op,stack[top].str);
top--;
return(op);
}
void main()
{
clrscr();
printf("ntt Program for postfix to infix conversion");
printf("ntEnter postfix expression ::nntt);
scanf("%s",input);
post2in();
getch();
}
void post2in()
{
char*op1,*op2,op[25];
int i=0;
while(input[i]!='0')
{
if(input[i]!='+'&& input[i]!='–'&& input[i]!='*'&&
input[i]!='/')
{
op[0]=input[i];
op[1]='0';
push(op);
}
else
{
op2=pop();
op1=pop();
sprintf(op,"(%s%c%s)",op1,input[i],op2);
free(op1);
free(op2);
push(op);
}
i++;
}
if(top==0)
{

22. print("ntinfix expression is::nntt%s",
stack[0].str);
}
else
{
print("ntlllegal input expression:operator
missingn");
}
}
13)C Program
/*******************************************************************
Conversion of postfix expression to prefix form
*******************************************************************/
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<process.h>
typedef struct node
{
char str[25];
}node;
node stack[20];
int top = –1;
char input[100];
void post2pre();
void push(char *op)
{
if(top == 20)
{
printf("nStack full");
exit(0);
}
top++;
strcpy(stack[top].str,op);
}
char *pop()
{
char *op;
op=(char *)malloc(25);
if(top==–1)
{
printf("ntlllegal expression : operand missing");
exit(0);
}
strcpy(op,stack[top].str);
top--;
return(op);
}

23. void main()
{
clrscr();
printf("ntt Program for postfix to prefix form");
printf("ntEnter postfix expression ::nntt);
scanf("%s",input);
post2pre();
getch();
}
void post2pre()
{
char*op1,*op2,op[25];
int i=0;
while(input[i]!='0')
{
if(input[i]!='+'&& input[i]!='–'&& input[i]!='*'&&
input[i]!='/')
{
op[0]=input[i];
op[1]='0';
push(op);
}
else
{
op2=pop();
op1=pop();
sprintf(op,"(%c%s%s)",input[i],op1,op2);
free(op1);
free(op2);
push(op);
}
i++;
}
if(top==0)
{
print("ntPrefix expression is::nntt%s",
stack[0].str);
}
else
{
print("ntlllegal input expression:operator
missingn");
}
}