郁闷的C小加（二）

郁闷的C小加（二）

时间限制： 1000 ms  |  内存限制： 65535 KB

难度：4

描述

聪明的你帮助C小加解决了中缀表达式到后缀表达式的转换（详情请参考“郁闷的C小加（一）”），C小加很高兴。但C小加是个爱思考的人，他又想通过这种方法计算一个表达式的值。即先把表达式转换为后缀表达式，再求值。这时又要考虑操作数是小数和多位数的情况。

输入

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

输出

对于每组测试数据输出结果包括两行，先输出转换后的后缀表达式，再输出计算结果，结果保留两位小数。两组测试数据之间用一个空行隔开。

样例输入

21+2=

(19+21)*3-4/5=

样例输出

12+=

3.00

1921+3*45/-=

119.20

从左向右扫描后缀表达式，遇到运算符就把栈顶两个元素出栈，执行运算，得到的结果再入栈.
例:(a+b)*c的逆波兰式为ab+c*，假设计算机把ab+c*按从左到右的顺序压入栈中，并且按照遇到运算符就把栈顶两个元素出栈，执行运算，
得到的结果再入栈的原则来进行处理，那么ab+c*的执行结果如下：
　　1）a入栈（0位置）
　　2）b入栈（1位置）
　　3）遇到运算符"+"，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置）
　　4）c入栈（1位置）
　　5）遇到运算符"*"，将d和c出栈，执行d*c的操作，得到结果e，再将e入栈（0位置）
三、直接计算中缀表达式思路：
1、定义两个栈，一个用来存取运算符，一个用来存取操作数。
2、从左向右扫描表达式，遇到操作数，直接存入操作数栈中，遇到运算符，将该运算符与运算符栈顶元素比较，若该运算符优先级高，直接
入栈，否则弹栈，同时取操作数栈的最上面两个元素和弹出的运算符进行运算，结果压入操作数栈中。直到运算符栈顶元素优先级比该运算符
优先级低。
3、扫描完毕后，运算符依次出栈。注意：只要有一个运算符出栈，就要去操作数栈中的最上面两个元素进行计算，并把结果压入操作数栈中。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
using namespace std;
int we(char a)//设定优先级
{
    switch(a)
    {
    case '-' :
    case '+' :
        return 1;
        break;
    case '/' :
    case '*' :
        return 2;
        break;
    case '(' :
        return 0;
        break;
    default :
        return -1;
    }
}
int main()
{
    int i,j,k,n,t,top,p;
    scanf("%d",&n);
    while(n--)
    {
        int f=0,k=0;
        char s[15];
        char s2[1000+10],s3[1000+10],s1[1000+10];
        double s4[10010];//看清是double型的
        memset(s4,0,sizeof(s4));
        scanf("%s",s1);
        t=strlen(s1);
        int j=-1,top=0;
        for(i=0; i<t; i++)
        {
            if((s1[i]>='0'&&s1[i]<='9')||s1[i]=='.')
            {
                s3[++j]=s1[i];
            }
            else if(s1[i]=='(')
            {
                s3[++j]=' ';//空格的作用就是在下次在把它转换成数字的时候好把数字分开
                s2[++top]=s1[i];
            }
            else if(s1[i]==')')
            {
                while(s2[top]!='(')
                {
                    s3[++j]=' ';
                    s3[++j]=s2[top];
                    --top;
                }
                s3[++j]=' ';
                --top;
            }
            else if(s1[i]=='/'||s1[i]=='*'||s1[i]=='-'||s1[i]=='+')
            {
                while(we(s1[i])<=we(s2[top]))
                {
                    s3[++j]=' ';
                    s3[++j]=s2[top];
                    --top;
                }
                s3[++j]=' ';
                s2[++top]=s1[i];
            }
        }
        while(top>=1)
        {
            s3[++j]=' ';
            s3[++j]=s2[top];
            --top;
            if(s2[1]=='(')
                break;
        }
        s3[++j]=' ';
        s3[++j]='\0';
        for(int i=0;i<j;i++)//输出后缀式
        {
            if(s3[i]!=' ')
                printf("%c",s3[i]);
        }
        printf("=\n");
        int p=0;//另开一个栈，用来计算
        k=0;
        for(int i=0; i<j; i++)//计算
        {
            if(s3[i]>='0'&&s3[i]<='9'||s3[i]=='.')//把字符串转换成数字压入s4栈里面
            {
                s[k++]=s3[i];
                f=1;
                continue;
            }
            if(f)
            {
                s[k]='\0';
                s4[p++]=atof(s);//把字符串变成数字压入栈里面
                f=0,k=0;
            }
            else if(s3[i]==' ') continue;
            else if(s3[i]=='+'||s3[i]=='-'||s3[i]=='*'||s3[i]=='/')
            {
                double we;
                double ni,ha;
                p=p-1;
                ni=s4[p];//弹出栈顶元素
                ha=s4[--p];//弹出栈顶元素
                if(s3[i]=='+')//计算
                {
                    we=ni+ha;
                    s4[p++]=we;//把运算的结果压入栈中
                }
                if(s3[i]=='-')
                {
                    we=ha-ni;
                    s4[p++]=we;
                }
                if(s3[i]=='*')
                {
                    we=ha*ni;
                    s4[p++]=we;
                }
                if(s3[i]=='/')
                {
                    we=ha/ni;
                    s4[p++]=we;
                }
            }
        }
  printf("%.2lf\n",s4[p-1]);//输出站顶元素
  printf("\n");
    }
    return 0;
}