NYoj35 表达式求值

表达式求值

时间限制： 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 <iostream>
#include <stack>
#include <cstdio>
using namespace std;

int judge(char symbol)//优先级判断
{
    switch(symbol)
    {
        case '(' : return 0;break;
        case '+' : return 1;break;
        case '-' : return 1;break;
        case '*' : return 2;break;
        case '/' : return 2;break;
        //default : return 0;
    }
}

int main()
{
    string a;
    int n,i,len;
    double x,y;
    char sym_top;
    cin >> n;
    while(n--)
    {
        cin >> a;
        len = a.length();
        stack<char>symbol;
        stack<double>figure;
        double temp = 0,temp2 = 0;
        for(i=0;i<len-1;)
        {
            temp = 0,temp2 = 0;
           if(a[i] >= '0' && a[i] <= '9')
           {


             while(a[i] >= '0' && a[i] <= '9')
             {
               temp *= 10;
               temp += a[i] - '0';
               i++;
               int flag = 0;
               if(a[i] == '.')//计算小数点后的数
               {
                   i++;
                   while(a[i] == '0')//计算小数点后出现0的情况
                   {
                       flag++;
                       i++;
                   }
                   while(a[i] >='0' && a[i] <= '9')
                   {
                       temp2 *= 10;
                       temp2 += a[i] - '0';
                       i++;
                   }
                   while(temp2 >= 1)
                   {
                       temp2 /= 10;
                   }
                   while(flag)
                   {
                       temp2 /= 10;
                       flag--;
                   }
                   temp += temp2;//将小数部分加到整数部分上
               }
             }
             figure.push(temp);//数入栈
           }


           if(a[i] == '(')
           {
               symbol.push(a[i]);
               i++;
           }

               if(a[i] == '+' || a[i] == '-' || a[i] == '*' || a[i] == '/')
               {
                    if(symbol.empty())
                    {
                        symbol.push(a[i]);
                        i++;
                        continue;
                    }

                    sym_top = symbol.top();
                    while(judge(a[i]) <= judge(sym_top))//关键，将当前运算符与栈顶比较，进行从左到右计算
                    {
                        y = figure.top();
                        figure.pop();
                        x = figure.top();
                        figure.pop();
                        switch(sym_top)
                        {
                            case '+' : figure.push(x + y);break;
                            case '-' : figure.push(x - y);break;
                            case '*' : figure.push(x * y);break;
                            case '/' : figure.push(x / y);break;
                        }
                        symbol.pop();
                        if(symbol.empty())
                           break;
                        sym_top = symbol.top();
                    }
                        symbol.push(a[i]);
                    i++;
               }
               if(a[i] == ')')//遇到又括号全部计算直到相遇“）”为止
               {
                   sym_top = symbol.top();
                   while(sym_top != '(')
                   {
                        y = figure.top();
                        figure.pop();
                        x = figure.top();
                        figure.pop();
                        switch(sym_top)
                        {
                            case '+' : figure.push(x + y);break;
                            case '-' : figure.push(x - y);break;
                            case '*' : figure.push(x * y);break;
                            case '/' : figure.push(x / y);break;
                        }
                        symbol.pop();
                        sym_top = symbol.top();
                   }
                   symbol.pop();//将"("出栈
                   i++;
               }
           }

           while(!symbol.empty())//将栈中剩余的进行运算
           { sym_top = symbol.top();
                        y = figure.top();
                        figure.pop();
                        x = figure.top();
                        figure.pop();
                        switch(sym_top)
                        {
                            case '+' : figure.push(x + y);break;
                            case '-' : figure.push(x - y);break;
                            case '*' : figure.push(x * y);break;
                            case '/' : figure.push(x / y);break;
                        }
                symbol.pop();
           }
        printf("%.2lf\n",figure.top());//数的栈顶即为最终值
    }
    return 0;
}