计算器处理程序（逆波兰）

朴灿烈づ我的快乐病毒、 2022-04-08 12:23 261阅读 0赞

### 题目： ###

读入一个只包含 +, -, \*, / 的非负整数计算表达式，计算该表达式的值。  
Input  
测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。  
Output  
对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。  
Sample Input  
1 + 2  
4 + 2 \* 5 - 7 / 11  
0  
Sample Output  
3.00  
13.36

##### 分析： #####

此题，基本思路是将中缀表达式转化为后缀表达式。从而用压栈出栈的方式，进行处理。

#include"stdio.h"
    #include"string.h"
    #define MAX_lenght 10000
    double atof1(char str[MAX_lenght])/*将字符串转化为double型的数*/
    {
        double f,f1;
        int i,l;
        double n;
        l=strlen(str);
        f=0;
        f1=0;
        i=0;
    
        while(str[i]!='.'&&i<l)
        {
            f=f*10+(str[i]-'0');
            i++;
        }
    
        n=10;
        while(i<l)
        {
            f1=f1+(str[i]-'0')/n;
            n=n*10;
            i++;
        }
    // printf("f=%0.2lf\n",f+f1);
        return f+f1;
    }
    typedef struct
    {
        double data[MAX_lenght];
        int top;
    } SqStack;//数字的存入。
    typedef struct
    {
        char data[MAX_lenght];
        int top;
    } SqStackchar;//符号的存入
    SqStack S;
    SqStackchar Symbol;
    void PUSHchar(char t)
    {
        if(Symbol.top==MAX_lenght-1)
            printf("SqStack more ERROR\n");
        else
        {
            Symbol.top++;
            Symbol.data[Symbol.top]=t;
    
        }
    }
    void POPchar(char *t)
    {
        if(Symbol.top==-1)
            printf("SqStackSymbol less ERROR\n");
        else
        {
            *t=Symbol.data[Symbol.top];
            Symbol.top--;
        }
    }
    void PUSH(double e)
    {
        if(S.top==MAX_lenght-1)
            printf("SqStack more ERROR\n");
        else
        {
            S.top++;
            S.data[S.top]=e;
    
        }
    }
    void POP(double *e)
    {
        if(S.top==-1)
            printf("SqStack less ERROR\n");
        else
        {
            *e=S.data[S.top];
            S.top--;
        }
    }
    int main()
    {
        char c,t,SM;
        double e,a,b;
        char str[MAX_lenght];
        int i,q;
    
        /*   这里是一开始模拟后缀表达式的计算过程所写的
        scanf("%c",&c);
        while(c!='#')
        {
            while(c>='0'&&c<='9')//这里是对数字的处理过程，将一个数字转化为double型
            {
                str[i++]=c;
                str[i]='\0';
                scanf("%c",&c);
                if(c==' ')//该数字结束
                {
                    e=atof1(str);
    
                    PUSH(e);
                    i=0;
                    break;
                }
            }
    
            switch(c)//四则运算
            {
            case '+':
                POP(&a);
                POP(&b);
                PUSH(a+b);
                break;
            case '-':
                POP(&a);
                POP(&b);
                PUSH(b-a);
                break;
            case '*':
                POP(&a);
                POP(&b);
                PUSH(a*b);
                break;
            case '/':
                POP(&a);
                POP(&b);
                if(a==0)
                {
                    printf("a=0了，除数不能为0；\n");
                    return -1;
                }
                else
                    PUSH(b/a);
                break;
            }
            scanf("%c",&c);
        }
        POP(&a);
        printf("%0.2lf\n",a);
        */
        q=0;
        while(1)//多组
        {
             S.top=-1;
             Symbol.top=-1;
             i=0;
        scanf("%c",&c);
        if(c=='0')/*这里是需要判断是否第一个为0且这一行只有一个0。则程序结束。需要注意的是不能直接break。因为，这一会如果不止一个0的话，程序是不能结束的。*/
            q=1;
        while(c!='\n')//到达换行则一组数据结束。
        {
            while(c>='0'&&c<='9')//这里是对数字的处理过程，将一个数字转化为double型
            {
                str[i++]=c;
                str[i]='\0';
                scanf("%c",&c);
                if(c==' '||c=='\n')//该数字结束
                {
                    e=atof1(str);
    
                    PUSH(e);
                    i=0;
                    break;
                }
            }//1 + 2 + 3 #
            switch(c)//对四个符号的处理。
            {
            case  '+':
                {
                SM=0;
                while(Symbol.top!=-1)//如果不是第一个符号了， 则需要将之前的符号取出进行运算
                {     POPchar(&SM);
                      if(SM=='(')
                            break;
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
    
    
                }
                if(SM=='(')//如果是因为SM=‘（‘退出的，SM是还需要的进栈的。
                    PUSHchar(SM);
                PUSHchar(c);
            }
            break;
            case '-':
               {SM=0;
                while(Symbol.top!=-1)
                {   POPchar(&SM);
                      if(SM=='(')
                            break;
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
                }
                if(SM=='(')
                    PUSHchar(SM);
                PUSHchar(c);
                }
                break;
            case '*':
            {   SM=0;
                while(Symbol.top!=-1)
                { POPchar(&SM);
                      if(SM=='('||SM=='+'||SM=='-')
                            break;
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
                }
                if(SM=='('||SM=='-'||SM=='+')
                    PUSHchar(SM);
                PUSHchar(c);
                }
                break;
            case '/':
                {SM=0;
                 while(Symbol.top!=-1)
                {POPchar(&SM);
                      if(SM=='('||SM=='+'||SM=='-')
                            break;
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
                }
                if(SM=='('||SM=='-'||SM=='+')
                    PUSHchar(SM);
                PUSHchar(c);}
                break;
            case ')':
                {
                while(Symbol.top!=-1)
                {  POPchar(&SM);
                      if(SM=='(')
                            break;
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
                }
             //   PUSHchar(c); 1 + 2 * ( 5 - 3 ) #
                }
                break;
    
            }
           if(c=='(')
             {PUSHchar(c);
    
             }
         if(c=='\n')
            break;
         scanf("%c",&c);
    
        }
              if(Symbol.top==-1&&S.top==0&&q==1)/*这里是判断是否是第一个0且这行只有一个0的情况*/
                 break;
                while(Symbol.top!=-1)//将符号栈中的符号取出，进行运算。
                { POPchar(&SM);
    
                    switch(SM)//四则运算
                    {
                    case '+':
                        POP(&a);
                        POP(&b);
                        PUSH(a+b);
                        break;
                    case '-':
                        POP(&a);
                        POP(&b);
                        PUSH(b-a);
                        break;
                    case '*':
                        POP(&a);
                        POP(&b);
                        PUSH(a*b);
                        break;
                    case '/':
                        POP(&a);
                        POP(&b);
                        if(a==0)
                        {
                            printf("a=0了，除数不能为0；\n");
                            return -1;
                        }
                        else
                            PUSH(b/a);
                        break;
                    }
    
                }
            POP(&a);//将结果取出
    
         printf("%0.2lf\n",a);
    
    
    
    }
    
    }