【表达式求值】中缀表达式转变为后缀表达式

参考blog：http://blog.csdn.net/Gengman/article/details/70236885#reply；

1.什么是中缀表达式

    中缀表达式就是我们正常写的表达式，比如：((1+2)*5+1)/4；

2.什么是后缀表达式

    后缀表达式就是根据中缀表达式转换来的，方便运算。

    ((1+2)*5+1)/4 ==> 12+5*1+4/ 

3.要先把中缀表达式转变为后缀表达式，方便计算；为什么？

   方便程序编写（好像是废话）；

4.中缀表达式怎么转变为后缀表达式；

    开辟：操作符栈 stack<char>oc、结果字符串ans[]；

    (1).操作数压到结果字符串；操作符玉如操作符栈；

    (2).当待压入操作符栈的操作符优先级大于栈顶操作符时，直接入栈；

          若小于等于栈顶操作符的话，栈顶操作符加入到结果字符串后面，直到遇到前括号‘（’或者栈顶操作符优先级小于待入栈操作符，最后待入栈操作符入栈；

    (3).如果时前‘（’直接入栈；

    (4).如果是后‘）’，将栈中操作符依次弹出并压入结果字符串，并弹出前‘(’不加入结果字符串；

    根据以上四个步骤，得到的就是后缀表达式；

5.得到后缀表达式，利用后缀表达式进行计算的顺序与结果与中缀表达式完全相同；

6.模拟一下过程，给出例子：

   (a+b)*(c+d)*e+f、a+b-c+d-e+f、0.3/(5*2+1)；

   对应后缀表达式：ab+cd+*e*f+、ab+c-d+e-f+、0.3#5#2*1+/；（#分隔符）

7.后缀表达式特点；

   (1).操作符位于操作数之后；  (2).没有括号；  (3).操作符没有优先级；

8.后缀表达式求值步骤；

   开辟操作数栈 stack<double>on；

   计算机处理后缀表达式求值问题是比较方便的，

   (1)即将遇到的操作数暂存于一个操作数栈中，

   (2)凡是遇到操作符，便从栈中pop出两个操作数，并将结果存于操作数栈中，直到对后缀表达式中最后一个操作数处理完，

   (3)最后一个压入栈中的数就是最后表达式的计算结果；

9.表达式求值例题；

nyoj 35表达式求值；

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<stack>
#include<algorithm>
using namespace std;

char ans[5000],s[1100];//ans结果字符串，s原串；

int cmp(char c)
{
    if(c=='(')  return 0;
    else if(c=='+'||c=='-')  return 1;
    else if(c=='*'||c=='/')  return 2;
}

double subans(double x,double y,char c)
{
    if(c=='+')  return x+y;
    if(c=='-')  return x-y;
    if(c=='*')  return x*y;
    if(c=='/')  return x/y;
}

int main()
{
    int T;
    stack<char>oc;//中缀->后缀 操作符栈；
    stack<double>on;//后缀->求值 操作数栈；

    scanf("%d",&T);
    while(T--)
    {
        int k=0;
//        memset(ans,0x00,sizeof(ans));
        while(!oc.empty())  oc.pop();
        while(!on.empty())  on.pop();
        scanf("%s",s);
        int len=strlen(s);
        //中缀-->后缀；
        for(int i=0; i<len; i++)
        {
            if((s[i]>='0'&&s[i]<='9')||s[i]=='.')
                ans[k++]=s[i];
            else if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/')
            {
                ans[k++]='#';
                if(oc.empty())
                    oc.push(s[i]);
                else
                {
                    while(!oc.empty()&&cmp(oc.top())>=cmp(s[i]))
                    {
                        ans[k++]=oc.top();
                        oc.pop();
                    }
                    oc.push(s[i]);
                }
            }
            else if(s[i]=='(')
            {
                oc.push(s[i]);
            }
            else if(s[i]==')')
            {
                while(oc.top()!='(')
                {
                    ans[k++]=oc.top();
                    oc.pop();
                }
                oc.pop();
            }
            else if(s[i]=='=')
            {
                while(!oc.empty())
                {
                    ans[k++]=oc.top();
                    oc.pop();
                }
            }
        }
        //得到后缀表达式 ans;
//        puts(ans);

         //后缀表达式求值；
        int pos=0;  
        for(int i=0; i<k; i++)
        {
            pos=0;
            if(ans[i]>='0'&&ans[i]<='9')//对操作数进行操作；
            {
                for(int j=i; j<k; j++)  
                {
                    if((ans[j]>='0'&&ans[j]<='9')||ans[j]=='.')
                        pos++;
                    else
                        break;
                }

                double k=1,sum1=0,sum2=0;
                for(int j=i+pos-1; j>=i; j--)
                {
                    if(ans[j]>='0'&&ans[j]<='9')
                    {
                        sum1+=(ans[j]-'0')*k;
                        k*=10;
                    }
                    else if(ans[j]=='.')
                    {
                        sum1/=k;
                        k=1;
                        sum2+=sum1;
                        sum1=0;
                    }
                }
                sum2+=sum1;
                on.push(sum2);  //报操作数压入操作数栈中；
                i+=pos-1;
            }
            else if(ans[i]=='+'||ans[i]=='-'||ans[i]=='*'||ans[i]=='/')
            {
                double x=on.top();on.pop();
                double y=on.top();on.pop();
                on.push(subans(y,x,ans[i]));  //求值，结果仍压入操作数栈；
            }
        }
        printf("%.2lf\n",on.top()); //处理操作数栈中只有一个操作数；
    }
    return 0;
}

2016河南省赛A题，表达式求值

本题于上题略有改动，加入了Smax运算，而且只有+和*操作符；

如果只有+、*两个运算符就不必须加上运算符的优先级相等这一判断；

我的这个程序用的还是上题模板，稍加改动的地方是把’，‘抽出作为Smax的操作符；

并且把使‘，’的优先级大于‘）’而且小于其他运算符的优先级；

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<stack>
#include<algorithm>
using namespace std;

char ans[5000],s[1100];//ans结果字符串，s原串；

int cmp(char c)
{
    if(c=='(')  return -1;
    else if(c==',')  return 0;
    else if(c=='+'||c=='-')  return 1;
    else if(c=='*'||c=='/')  return 2;
}

double subans(double x,double y,char c)
{
    if(c=='+')  return x+y;
    if(c=='-')  return x-y;
    if(c=='*')  return x*y;
    if(c=='/')  return x/y;
    if(c==',')
    {
        int ans1=0;
        int xx=(int)x;
        while(xx)
        {
            ans1+=(xx%10);
            xx/=10;
        }
        int ans2=0;
        int yy=(int)y;
        while(yy)
        {
            ans2+=(yy%10);
            yy/=10;
        }
        return max(ans1,ans2);
    }
}

int main()
{
    int T;
    stack<char>oc;//中缀->后缀 操作符栈；
    stack<double>on;//后缀->求值 操作数栈；

    scanf("%d",&T);
    while(T--)
    {
        int k=0;
//        memset(ans,0x00,sizeof(ans));
        while(!oc.empty())  oc.pop();
        while(!on.empty())  on.pop();
        scanf("%s",s);
        int len=strlen(s);
        s[len]='=';
        //中缀-->后缀；
        for(int i=0; i<=len; i++)
        {
            if((s[i]>='0'&&s[i]<='9')||s[i]=='.')
                ans[k++]=s[i];
            else if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'||s[i]==',')
            {
                ans[k++]='#';
                if(oc.empty())
                    oc.push(s[i]);
                else
                {
                    while(!oc.empty()&&cmp(oc.top())>=cmp(s[i]))
                    {
                        ans[k++]=oc.top();
                        oc.pop();
                    }
                    oc.push(s[i]);
                }
            }
            else if(s[i]=='(')
            {
                oc.push(s[i]);
            }
            else if(s[i]==')')
            {
                while(oc.top()!='(')
                {
                    ans[k++]=oc.top();
                    oc.pop();
                }
                oc.pop();
            }
            else if(s[i]=='=')
            {
                while(!oc.empty())
                {
                    ans[k++]=oc.top();
                    oc.pop();
                }
            }
        }
        //得到后缀表达式 ans;
//        puts(ans);

         //后缀表达式求值；
        int pos=0;
        for(int i=0; i<k; i++)
        {
            pos=0;
            if(ans[i]>='0'&&ans[i]<='9')//对操作数进行操作；
            {
                for(int j=i; j<k; j++)
                {
                    if((ans[j]>='0'&&ans[j]<='9')||ans[j]=='.')
                        pos++;
                    else
                        break;
                }

                double k=1,sum1=0,sum2=0;
                for(int j=i+pos-1; j>=i; j--)
                {
                    if(ans[j]>='0'&&ans[j]<='9')
                    {
                        sum1+=(ans[j]-'0')*k;
                        k*=10;
                    }
                    else if(ans[j]=='.')
                    {
                        sum1/=k;
                        k=1;
                        sum2+=sum1;
                        sum1=0;
                    }
                }
                sum2+=sum1;
                on.push(sum2);  //报操作数压入操作数栈中；
                i+=pos-1;
            }
            else if(ans[i]=='+'||ans[i]=='-'||ans[i]=='*'||ans[i]=='/'||ans[i]==',')
            {
                double x=on.top();on.pop();
                double y=on.top();on.pop();
                on.push(subans(y,x,ans[i]));  //求值，结果仍压入操作数栈；
            }
        }
        printf("%d\n",(int)on.top()); //处理操作数栈中只有一个操作数；
    }
    return 0;
}