Question

Given the following C code. Develop a evaluate post fix function that calculates the converted post fix.

#include <stdio.h>
#include <ctype.h>
#define max 10
char s[100];
int top=-1;
void push(char);
char pop();
int precede(char);
main(){
   char infix[100],postfix[100],ch;
   int i=0,j=0;
   // Read infix expression from user
   printf("Enter infix expression:");
   scanf("%s",infix);
   // evaluate each char in infix expression
   while((ch=infix[i++])!='\0'){
       // if it is number, add it to postfix expression
       if(isalnum(ch)){
           postfix[j++]=ch;
       }else if(ch=='('){
           // if it open paranthesis, push it to stack
           push(ch);
       }else if(ch==')'){
           // if it is closing paranthesis, pop all the
           // numbers from stack and add it postfix
           while(s[top]!='('){
               postfix[j++]=pop();
           }
           top--;
       }else{
           /*
               if if is operator, if stack is empty or precedence of current operator is
               greater than precedence of top of the stack, then push it into stack.
               otherwise pop all the operators from stack until precedence of top of the stack is
               less than precedence of the current operator.
           */
           if(top==-1||precede(ch)>precede(s[top])){
               push(ch);
           }else{
               while(precede(ch)<=precede(s[top])&&top!=-1){
                   postfix[j++]=pop();
               }
               push(ch);
           }
       }
   }
   while(top!=-1){
       postfix[j++]=pop();
   }
   postfix[j]='\0';
   printf("Infix expression = %s\nPostfix expression = %s",infix,postfix);
}
void push(char a)
{
   s[++top]=a;
}
char pop(){
   return s[top--];
}
int precede(char a){
   if(a=='('||a==')'){
       return 1;
   }else if(a=='-'||a=='+'){
       return 2;
   }else if(a=='%'||a=='/'||a=='*'){
       return 3;
   }
}

Answer 1

#include <stdio.h>
#include <stdlib.h>
struct Stack
{
int top;
unsigned capacity;
int* array;
};
struct Stack* createStack( unsigned capacity )
{
struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));
  
if (!stack) return NULL;
  
stack->top = -1;
stack->capacity = capacity;
stack->array = (int*) malloc(stack->capacity * sizeof(int));
  
if (!stack->array) return NULL;
  
return stack;
}
int isEmpty(struct Stack* stack)
{
return stack->top == -1 ;
}
char pop(struct Stack* stack)
{
if (!isEmpty(stack))
return stack->array[stack->top--] ;
return '$';
}
void push(struct Stack* stack, char op)
{
stack->array[++stack->top] = op;
}
int evaluatePostfix(char* postfix)
{

struct Stack* stack = createStack(strlen(postfix));
int i;
  
  
if (!stack) return -1;
  
for (i = 0; postfix[i]; ++i)
{
  
if (isdigit(postfix[i]))
push(stack, postfix[i] - '0');
  
  
else
{
int val1 = pop(stack);
int val2 = pop(stack);
switch (postfix[i])
{
case '+': push(stack, val2 + val1); break;
case '-': push(stack, val2 - val1); break;
case '*': push(stack, val2 * val1); break;
case '/': push(stack, val2/val1); break;
case '%': push(stack, val2%val1); break;
}
}
}
return pop(stack);
}

int main()
{
char postfix[100];
scanf("%s",postfix);
printf ("postfix evaluation: %d", evaluatePostfix(postfix));
}

Please upvote if you found this solution useful and comment for any doubts.