题目描述

读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。

输入

测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。

输出

对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。

样例输入

30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92
0

样例输出

12178.21

总结

不知道哪里错了，不能AC，样例是的对的

代码

#include <stdio.h>
#include <string.h>
#include <math.h>

typedef struct
{
    double num;
    int flag;//flag为1代表数字,flag为0代表符号
    char sym;
}factor;



int priority(char c)
{
    if(c=='*'||c=='/')return 2;
    else return 1;
}


void delspace(char s[],char newstr[])
{
    int i;
    int count=0;
    for(i=0;i<strlen(s);i++)
    {
        if(s[i]!=' ')
        {
            newstr[count++]=s[i];
        }
    }
    newstr[count]='\0';//表示字符串结束 0~count-1为字符串内容
    //没有上述语句会打印出现奇怪的符号
}

double totalcal(factor postorder[],int len)//len为结构体postorder长度
{
    double a,b,c;
    double stack[50];
    int top=-1;
    for(int i=0;i<len;i++)
    {
        if(postorder[i].flag==1)stack[++top]=postorder[i].num;//是数字就入栈
        else
        {//是运算符
            b=stack[top--];
            a=stack[top--];
            if(postorder[i].sym=='+')c=a+b;
            else if(postorder[i].sym=='-')c=a-b;
            else if(postorder[i].sym=='*')c=a*b;
            else c=a/b;
            stack[++top]=c;//入栈
        }
    }
    return stack[0];

}



int main()
{
    freopen("input.txt","r",stdin);
    char s[210],newstr[210];//s用于输入,newstr用于存储删除space后的字符串
    char stack[50];
    int top=-1;//stack和top用于初始化栈，用于存储符号
    factor postorder[100];
    double temp;
    int len=0;// postorder用于存储后缀表达式,len表示后缀表达式的长度
    while(gets(s)!=NULL)
    {
        if(s[0]=='0')continue;
        delspace(s,newstr);//去空格
        //puts(newstr);
        for(int i=0;i<strlen(newstr);i++)//转后缀表达式
        {
            if(newstr[i]>='0'&&newstr[i]<='9')
            {
                temp=newstr[i]-'0';
                while((i+1)<strlen(newstr)&&newstr[i+1]>='0'&&newstr[i+1]<='9')
                {
                    i++;
                    temp=temp*10+newstr[i]-'0';
                }
                postorder[len].flag=1;
                postorder[len++].num=temp;
                temp=0;
            }
            else
            {
                if(top==-1)stack[++top]=newstr[i];//栈空入栈
                else if(priority(newstr[i])>priority(stack[top]))
                {
                    stack[++top]=newstr[i];
                }//栈不空，但是优先级比栈顶元素要大，入栈
                else
                {
                    while(top!=-1&&priority(newstr[i])<=priority(stack[top]))
                    {
                        postorder[len].sym=stack[top--];
                        postorder[len++].flag=0;
                    }
                    stack[++top]=newstr[i];
                }//栈不空，优先级比栈顶元素要小，元素出栈
            }
        }
        while(top!=-1)
        {
            postorder[len].sym=stack[top--];
            postorder[len++].flag=0;
        }
        //以上生成后缀表达式postorder;下面计算后缀表达式
        printf("%.2lf\n",totalcal(postorder,len));
        top=-1;
        len=0;
    }
}