NYOJ 35 表达式求值

表达式求值
时间限制：3000 ms  |  内存限制：65535 KB
难度：4

描述
    ACM队的mdd想做一个计算器，但是，他要做的不仅仅是一计算一个A+B的计算器，他想实现随便输入一个表达式都能求出它的值的计算器，现在请你帮助他来实现这个计算器吧。
    比如输入：“1+2/4=”，程序就输出1.50（结果保留两位小数）

    输入
        第一行输入一个整数n，共有n组测试数据（n<10)。
        每组测试数据只有一行，是一个长度不超过1000的字符串，表示这个运算式，每个运算式都是以“=”结束。这个表达式里只包含+-*/与小括号这几种符号。其中小括号可以嵌套使用。数据保证输入的操作数中不会出现负数。
        数据保证除数不会为0
    输出
        每组都输出该组运算式的运算结果，输出结果保留两位小数。
    样例输入

        2
        1.000+2/4=
        ((1+2)*5+1)/4=

    样例输出

        1.50
        4.00


#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stack>
#define Maxsize 1100
using namespace std;
stack<char>osta;//#include<stack>
stack<double>dsta;
char ch[Maxsize];
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%s",&ch[1]);//从下标为1开始输入
        int len=strlen(&ch[1]);//#include<string.h>
        ch[0]='(';ch[len]=')';//每完成一个括号里的所有运算后，释放osta栈中的括号
        for(int i=0;i<=len;i++)
        {
            if(ch[i]=='(')
            {
                osta.push(ch[i]);//在栈顶增加元素   #include<stack> 遇到 ( 即压入osta栈中
            }
            else if(ch[i]==')')//遇到）必有运算，前面必有运算符且要进行运算 ，消去（
            {
                while(osta.top()!='(')//返回栈顶元素
                {
                    double a=dsta.top();dsta.pop();
                    double b=dsta.top();dsta.pop();
                    double c=0;
                    switch(osta.top())
                    {
                        case '+':c=b+a;break;
                        case '-':c=b-a;break;
                        case '*':c=b*a;break;
                        case '/':c=b/a;break;
                    }
                    dsta.push(c);
                    osta.pop();//释放运算符
                }
                osta.pop();//释放(
            }
            else if(ch[i]=='+'||ch[i]=='-')//遇到 + -号 ，有两种情况
            {
                while(osta.top()!='(')//当osta栈顶不是(时，表明有运算符，即需运算了，否则表明前面没有运算符，只有一个数字，就需要储存
                {
                    double a=dsta.top();dsta.pop();//把dsta栈顶值赋予a，释放
                    double b=dsta.top();dsta.pop();//同上
                    double c=0;
                    switch(osta.top())
                    {
                        case '+':c=b+a;break;
                        case '-':c=b-a;break;
                        case '*':c=b*a;break;
                        case '/':c=b/a;break;
                    }
                    dsta.push(c);//运算后，把c压入dsta栈顶
                    osta.pop();//释放运算符
                }
                osta.push(ch[i]);//若上个运算完成后，再次储存运算符
            }
            else if(ch[i]=='*'||ch[i]=='/')
            {
                if(osta.top()=='*')
                {
                    double a=dsta.top();dsta.pop();
                    double b=dsta.top();dsta.pop();
                    dsta.push(b*a);
                    osta.pop();
                }
                else if(osta.top()=='/')
                {
                    double a=dsta.top();dsta.pop();
                    double b=dsta.top();dsta.pop();
                    dsta.push(b/a);
                    osta.pop();
                }
                osta.push(ch[i]);
            }
            else if(ch[i]<='9'&&ch[i]>='0')//遇到0~9
            {
                double v=0;
                int b=i;
                bool flag=false;//标记
                while(ch[i]<='9'&&ch[i]>='0'||ch[i]=='.')//使用循环，用dsta栈储存数字（包括小数）
                {
                    if(ch[i]=='.')
                    {
                        b=i;
                        flag=true;
                    }
                    else
                    v=v*10+ch[i]-'0';
                    ++i;
                }
                --i;
                if(flag==true)
                {
                    dsta.push(v/pow(10,i-b));//#include<math.h> 把小数压入
                }
                else
                {
                    dsta.push(v);//把整数压入
                }
            }
        }
        printf("%.2lf\n",dsta.top());
        dsta.pop();
    }
    return 0;

}

思路注释：遇到‘*'||'/’运算符，则根据运算符的优先级别，只对'*''/'进行运算，当然若osta.top()=='(',则不需运算只需压入栈中即可；若遇到'+’||'-‘运算符是，栈
顶有'*’'/‘'+’'-‘四种运算中的一种可能而且前面运算符数量只存在一个（运算符运算一个释放一个），所以不需考虑运算级优先的问题，当然若osta.top()=='(',则表示
前面没有运算符，只需压入即可；若遇到'(’，则只管压入栈顶即可；若遇到')‘，则sota.top!='(',表示前面有运算符，可能是'*’'/‘'+’'-‘中的一种，则只需计算后释
放运算符即可，若是，释放'(’；若遇到数字运算符，根据题意，要考虑小数点，用flag标记有无小数点，先把数字读完，若有小数点，则标记，并做dsta.push(v/pow(10,i-b
））处理，把小数压入栈顶，若无，则直接压入即可。每一种数据结构都有不同的逻辑运算，但又要符合其物理结构，这是个人理解，也许有纰漏，我会不断更新，改正，希望
对大家有所帮助