Upcoming SlideShare
×

# Stack prgs

653 views

Published on

Stack prgs

1 Like
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
Your message goes here
• Be the first to comment

Views
Total views
653
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
21
0
Likes
1
Embeds 0
No embeds

No notes for slide

### Stack prgs

1. 1. 1)‘C’ Program/************************************************************Program for implementing a stack using arrays.It involvesvarious operations such as push,pop,stack empty,stack full anddisplay.*************************************************************/#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. 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. 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 programhandles postfix expressions with only binary arithmaticoperators +,-,*,/ and ^. Operands are single digit numbersbetween 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. 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. 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. 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 FunctionInput:noneOutput:noneCalled BY:O.S.Calls:postfix*/void main(void){ clrscr(); printf(―ntEnter the infix expression :: nntt‖); scanf(―%s‖, inf); postfix(); getch();}/*The postfix FunctionInput:noneOutput:none
7. 7. Called By:mainCalls: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. 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. 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. 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. 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. 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. 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 20int 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. 14. lb=sum+1; ub=sum+size[index]; }}/* stfull FunctionIt 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 FunctionIt 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. 15. int top; for(top=lb;top<=ub;top++) if(stack[top]==-1) break; stack[top]=item; return;}/* pop FunctionIt 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. 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. 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 functionInput:the numer nOutput: factorial of nCalled By:mainCalls: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 functionInput:noneOutput:noneCalled By:O.S.
18. 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 atcertain location.For e.g.the sixth number in fibonacci serieswill 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. 19. series‖,n,num); getch();}/********************** End of Program ***********************/10)C Program/*************************************************************Program for Multiplication Of natural numbers.The multiplicationtwo numbers is considerd.This is program uses the recurssivedefinition.*************************************************************//*header files*/#include<stdio.h>#include<conio.h>/*************************************************************mul FunctionInput:two numbers a,bOutput:returns the multiplication resultCalled by:mainCalls:mul i.e.itself*************************************************************/mul(int a,int b){ if(b==1) return a; else return(mul(a,b-1)+ a);}/*************************************************************main FunctionInput:noneOutput:noneCalled 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 twointegers.*************************************************************/#include<stdio.h>#include<conio.h>#include<stdlib.h>int gcd(int a,int b){
20. 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. 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. 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. 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"); }}