nyoj ACM:前缀式计算( 堆栈的使用 或 递归 )

                    前缀式计算
                    时间限制：1000 ms  |  内存限制：65535 KB
                    难度：3

---

                        描述

先说明一下什么是中缀式：

如2+(3+4)*5这种我们最常见的式子就是中缀式。

而把中缀式按运算顺序加上括号就是：(2+((3+4)*5))

然后把运算符写到括号前面就是+(2 *( +(3 4) 5) )

把括号去掉就是：+ 2 * + 3 4 5

最后这个式子就是该表达式的前缀表示。

给你一个前缀表达式，请你计算出该前缀式的值。

比如：

• 2 * + 3 4 5的值就是 37

                                            输入
  

  有多组测试数据，每组测试数据占一行，任意两个操作符之间，任意两个操作数之间，操作数与操作符之间都有一个空格。输入的两个操作数可能是小数，数据保证输入的数都是正数，并且都小于10，操作数数目不超过500。
  以EOF为输入结束的标志。
  输出
  对每组数据，输出该前缀表达式的值。输出结果保留两位小数。
  样例输入

• 2 * + 3 4 5
• 5.1 / 3 7
  样例输出
  37.00
  5.53

---

感悟：但凡遇到表达式的问题，首先要想到使用堆栈来处理。

我的思路是用两个堆栈实现的，但是看了网上大神的代码，好像用递归实现更加NB。
我的思路：
1. 用数组s接受前缀表达式，连同空格一起接收。
2. 然后将s全部压入堆栈A中
3. 每次从堆栈A中取出一个字符x。

• 如果是数字，那么就看A的下一个字符y是数字还是小数点还是空格。
  
  • 如果y是空格，直接将x压入B中；
  • 如果y是小数点，那么再取小数点下一个数，三者合并就得到完整的小数，然后压入B中；
  • 如果y 是数字，那么表明x和y同为某一小数的小数部分，且y是x的前一位，那么不断循环，直到找到小数点，再加上小数点后面的数字，3者合并，就得到一个完整的小数，然后压入堆栈B中
• 如果是空格，忽略掉即可。
• 如果是x运算符，那么M= B.POP() , N= B.POP() , 然后M,X,N运算，将结果压入B中

4。上面不断循环，直到堆栈A为空

#include<iostream>
#include<cstdio>
#include<stack>
#include<cstring>

using namespace std;
int main()
{
    stack<char> A;
    stack<double> B;
    char s[2010];
    while(gets(s))
    {
        for(int i=0;i<strlen(s);i++)
        {
            A.push(s[i]);
        }

        while(!A.empty())
        {
            char x=A.top();
            double f;
            A.pop();
            if(x>='0' && x<='9')//如果是数值，那么A一定不为空 
            {
                char y=A.top();
                if(y>='0' && y<='9')
                {
                    f=x-'0';
                    while(y!='.')
                    {
                        A.pop();
                        f=(y-'0')+f*0.1 ;
                        y=A.top();
                    }

                    A.pop();
                    y=A.top();
                    A.pop();
                    f=(y-'0')+f*0.1;
                    B.push(f);
                }
                else if(y=='.')
                    {   
                        A.pop();
                        y=A.top();
                        A.pop();
                        B.push((y-'0')+(x-'0')*0.1);
                    }
                    else
                    {
                        B.push(x-'0');
                    }

            } 
            else if(x==' ')
            {
                continue;
            }
            else if(x=='+' || x=='-' || x=='*' || x=='/')
                  {
                    double l=B.top();
                    B.pop();
                    double r=B.top();
                    B.pop();
                    switch(x)
                    {
                        case '+': B.push(l+r);break;
                        case '-': B.push(l-r);break;
                        case '*': B.push(l*r);break;
                        case '/': B.push(l/r);break;
                    }
                  }     
        }

        printf("%0.2lf\n",B.top());
        B.pop();

    }
    return 0;
}

大神的递归代码：
可惜不是很懂。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<sstream>
using namespace std;
stringstream ss;
double value;
char ch;
double val()
{
    ss>>ch;
    switch(ch)
    {
    case '+':return val()+val();
    case '-':return val()-val();
    case '*':return val()*val();
    case '/':return val()/val();
    default:ss.unget();ss>>value;return value;
    }
}

int main()
{
    string str;
    while(getline(cin,str))
    {
        ss.clear();
        ss<<str;
        printf("%.2f\n",val());
    }
}