将表达式转换为后缀的程序

Question

i am not getting correct output for this program getting as abcde-*++ for give input in main

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

 struct Stack{
   int capacity;
   int top;
   int *array;
 };
 struct Stack* createstack(int capacity){
     struct Stack* stack=(struct Stack*)malloc(sizeof(struct Stack));
     stack->top=-1;
     stack->capacity=capacity;
     stack->array=(int*)malloc(sizeof(int)*capacity);
     return stack;
     }
 char pop(struct Stack* stack){
     return(stack->array[stack->top--]);
 }
 void push(struct Stack* stack,char ch ){

     stack->array[++stack->top]=ch;

}
 int isempty(struct Stack* stack){

    return(stack->top==-1);
}
int isfull(struct Stack* stack){
    return(stack->top==stack->capacity-1);
}
int isfront(struct Stack* stack){
    return(stack->array[stack->top]);
}




int precedence(char ch){
    switch(ch){
      case 1: ch=='+';
      case 2: ch=='-';
         return 1;
      case 3: ch=='*';
      case 4: ch=='/';
         return 2;
      case 5: ch=='^';
         return 3;

      return-1;
    }

}
int isoperand(char ch){

    return(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z');
}
void infixtopostfix(struct Stack* stack,char* exp){
       int i,k=-1;
       char res[100];
       for(i=0;exp[i];i++){
          ///if an operand is encountered
         if(isoperand(exp[i]))
            res[++k]=exp[i];
          ///if an operator is encountered
          else{
       // if(isempty(stack)||precedence(isfront(stack))<precedence(exp[i]))

        //else
            while(!isempty&&precedence(isfront(stack))>=precedence(exp[i]))
            res[++k]=pop(stack);
            push(stack,exp[i]);




         }
     }
    while(!isempty(stack))
        res[++k]=pop(stack);

        res[++k]='\0';
      printf("%s",res);

}
int main(){
struct Stack* stack=createstack(100);
char arr[100]="a+b+c*d-e";
infixtopostfix(stack,arr);
}

This program is to convert the expression from infix to postfix Here is the Algorithm

Algorithm 1. Scan the infix expression from left to right.

2. If the scanned character is an operand, output it.

3. Else,

…..3.1 If the precedence of the scanned operator is greater than the precedence of the operator in the stack(or the stack is empty), push it. …..

3.2 Else, Pop the operator from the stack until the precedence of the scanned operator is less-equal to the precedence of the operator residing on the top of the stack. Push the scanned operator to the stack.

6. Repeat steps until infix expression is scanned.
7. Pop and output from the stack until it is not empty. i Am not getting correct output getting as abcde-*++ for the given input in my main function

Answer 1

I don't know if these are your only problems, but two things come to mind:

As @rici pointed out, your precedence function doesn't work the way you think it should. Correct would be:

int precedence(char ch){
    switch(ch){
      case '+':
      case '-':
         return 1;
      case '*':
      case '/':
         return 2;
      case '^':
         return 3;
      default: 
         return-1;
    }
}

When you're checking precedence, you have this conditional:

while(!isempty&&precedence(isfront(stack))>=precedence(exp[i]))

That's never going to work because !isempty will always evaluate to false. You're asking here if the address of the isempty function is null. It's not. What you really want to do is check whether the stack is empty:

while(!isempty(stack) && precedence(isfront(stack))>=precedence(exp[i]))

That will call the isempty function.

You really should learn to use your debugger. Single-stepping your code would quickly reveal the errors I noted above.

A couple of notes on your stack implementation.

You have a latent bug in pop . If somebody calls it when the stack is empty, it will either crash because you're trying to accessing array[-1] , or it will succeed in accessing array[-1] , and return a bogus value. You're better off checking the value of top , and throwing an exception (or crashing the program with a message), than returning a bad value. Depending on clients to call isEmpty before calling pop is unreliable.

You have a similar error in push . Trying to access beyond the bounds of the array is undefined behavior. The program might continue working, and it might crash. In the case of push , you might end up pushing a value that is subsequently changed by something else, and then pop returns a value that you didn't push.

Because of the bug in pop , your isEmpty function also has a bug. If top ever gets decremented lower than -1 , isEmpty will return false . Rather than checking for == -1 , you should check for < 0 . Even if you fix the pop problem, checking for < 0 is better. Defense in depth.

The name of the function that looks at the top of the stack without popping it is typically called peek , not isfront .