利用栈计算表达式的值

假设算术表达式只包含”+”、“-”、“*”、“/”、正整数和括号的合法数学表达式，求算术表达式值。

过程是：先将算术表达式转换成后缀表达式(逆波兰式)，然后对该后缀表达式求值。

　　1)将算术表达式exp转换成后缀表达式postexp;

　　2)对后缀表达式postexp求值。

中缀表达式a*b+c变成后缀表达式是ab*c+

（1）中缀表达式转换成后缀表达式：

a.从左到右逐个扫描中缀表达式中的各项，遇到结束符“#”转到（6），否则继续；

b.遇到操作数直接输出

c.若遇到右括弧“）”，则连续出栈输出，直到遇到左括弧“（”为止。其中，左括弧出栈但是并不输出，否则继续；

d.若是其他操作符，则和栈顶的操作符比较优先级，若小于等于栈顶操作符的优先级，则连续出栈输出，直到大于栈顶操作符的优先级结束，操作符进栈；

e.转到a操作；

f.输出栈中剩余的操作符（#除外）。

实现这个转换的关键是确定操作符的优先级，因为优先级决定操作符是否进栈和出栈，同时操作符在栈内外的优先级不同。（越大越高）

栈外：左括弧  乘除  加减  右括弧  结束符#

               7            4       2         1            0

栈内：左括弧  乘除  加减  右括弧  结束符#

                1           5        3        7          0

（2）后缀表达式的计算

从左往右扫描后缀表达式，遇到操作数就进栈，遇到操作符就从栈中弹出两个操作数，执行相应的运算，并将结果进栈。如此下去，直到遇到结尾符#结束，弹出的栈顶元素就是结果。注意这里只讨论双目运算符，在弹出的两个操作数栈，先出栈的放在操作符的右边，后出栈的放在左边。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
//符号栈
struct opstack{
    char data[MaxSize];//存储操作符 
    int top;//指向栈顶的指针 
}op;
//数值栈
struct ststack{
    float data[MaxSize];//存储操作符数 
    int top;//指向栈顶的指针 
}st;
//将算术表达式exp转换为后缀表达式postexp
void trans(char exp[],char postexp[]){
    char ch;
    int i=0,j=0; //i扫描exp的下标,j扫描postexp的下标
    op.top=-1;
    ch=exp[i]; i++;
    while (ch != '\0')
    {
        switch(ch){
        case '(':    //左括号
            op.top++; op.data[op.top]=ch;
            break;
        case ')':   //右括号
            while(op.data[op.top]!='(')//若遇到右括弧“）”，则连续出栈输出，直到遇到左括弧“（”为止。其中，左括弧出栈但是并不输出 
            {
                postexp[j]=op.data[op.top]; j++;
                op.top--;
            }
            op.top--;
            break;
        case '+':   //为'+'或'-'时，其优先级不大于栈顶任何运算符的优先级，直到')'
        case '-':
            while (op.top!=-1 && op.data[op.top]!='(')
            {
                postexp[j]=op.data[op.top]; j++;
                op.top--;
            }
            op.top++; op.data[op.top]=ch;
            break;
        case '*':
        case '/':  //为'*'或'/'时，其优先级不大于栈顶为'*'或'/'的优先级，直到')'
            while(op.top!=-1 && op.data[op.top]!='('
                && (op.data[op.top]=='*' || op.data[op.top]=='/')){
                postexp[j]=op.data[op.top]; j++;
                op.top--;
            }
            op.top++; op.data[op.top]=ch;
            break;
        case ' ': break;  //过滤空格
        default:
            while (ch>='0' && ch<='9')
            {
                postexp[j]=ch; j++;
                ch=exp[i]; i++;
            }
            i--;
            postexp[j]='#'; j++;
            //postexp[j]=' '; j++; //用空格标识一个数值串结束

        }
        ch=exp[i]; i++;
    }

    while(op.top!=-1){ //此时，exp扫描完毕，栈不空时出栈并存放到postexp中
        postexp[j]=op.data[op.top]; j++;
        op.top--;
    }
    postexp[j]='\0'; //给postexp表达式添加结束标识

}

//对后缀表达式postexp求值
float compvalue(char postexp[]){
    float d;
    char ch;
    int i=0;
    st.top=-1;
    ch=postexp[i]; i++;
    while (ch!='\0')
    {
        switch(ch){
        case '+': st.data[st.top-1]=st.data[st.top-1]+st.data[st.top];//遇到操作符就弹出两个数 并将结果进栈 
            st.top--; break;
        case '-': st.data[st.top-1]=st.data[st.top-1]-st.data[st.top];
            st.top--; break;
        case '*': st.data[st.top-1]=st.data[st.top-1]*st.data[st.top];
            st.top--; break;
        case '/':
            if(st.data[st.top]!=0)
                st.data[st.top-1]=st.data[st.top-1]/st.data[st.top];
            else{
                printf("\n\t除零错误!\n");//防止除数为0 
                exit(0);
            }
            st.top--; break;
        default: 
            d=0;
            while (ch>='0' && ch<='9')//遇到操作数就进栈直到#为止 
            {
                d=10*d+ch-'0';
                ch=postexp[i]; i++;
            }
            st.top++;
            st.data[st.top]=d;

        }
        ch=postexp[i]; i++;
    }
    return st.data[st.top];//输出栈顶元素就是结果 

}

int main()
{
    char exp[20];
    scanf("%s",exp);
    char postexp[30];
    float f=0.0;
    //求exp的逆波兰式,得到postexp
    trans(exp,postexp);
    //对postexp求值
    f=compvalue(postexp);
    printf("%s = %.2f\n",exp,f);
	return  0;
}