四则运算&简单计数器（有加减乘除，没有括号）

算法实现中缀转为后缀表达式

首先需要分配2个栈，一个作为临时存储运算符的栈S1（含一个结束符号），一个作为输入逆波兰式的栈S2（空栈），S1栈可先放入优先级最低的运算符#，注意，中缀式应以此最低优先级的运算符结束。可指定其他字符，不一定非#不可。从中缀式的左端开始取字符，逐序进行如下步骤：
（1）若取出的字符是操作数，则分析出完整的运算数，该操作数直接送入S2栈
（2）若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，如果该运算符优先级(不包括括号运算符) 大于 S1栈栈顶运算符优先级，则将该运算符进S1栈，否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）该运算符优先级，最后将该运算符送入S1栈。
（3）若取出的字符是“（”，则直接送入S1栈顶。
（4）若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。
（5）重复上面的1~4步，直至处理完所有的输入字符
（6）若取出的字符是“#”，则将S1栈内所有运算符（不包括“#”），逐个出栈，依次送入S2栈。
完成以上步骤，S2栈便为逆波兰式输出结果。不过S2应做一下逆序处理。便可以按照逆波兰式的计算方法计算了！

计算机如何计算后缀表达式？

下面以(a+b)c为例子进行说明：
(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位置）
经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。
逆波兰式除了可以实现上述类型的运算，它还可以派生出许多新的算法，数据结构，这就需要灵活运用了。逆波兰式只是一种序列体现形式。

详见百度百科

题目描述

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

输入

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

输出

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

样例输入

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

样例输出

12178.21

其实下面的代码去掉空格是错的，正确的如下： (因为删掉前面的位置，位置会变，但是i会出错)

for(int i=s.length()-1;i>=0;i–)
{
if(s[i] == ’ ') s.erase(s.begin()+i); //去掉空格
}

#include<bits/stdc++.h>
using namespace std;

struct node{
	double num;
	char op;
	bool flag;  //true代表操作数，false代表操作符 
}; 

string str; 
stack<node> s;  //操作符栈 
queue<node> q;  //后缀表达式序列 
map<char,int> op;   //优先级定义 

void Change(){    //转为后缀式 
	 double num;
	 node temp;
	 for(int i = 0; i < str.length();){  
	 	if((str[i] >= '0'&& str[i] <='9'))  //如果是数字push到p去 
	 	{
	 		temp.flag = true;  //标记是数字 
	 		temp.num = str[i]-'0';
	 		i++;
	 		while(i<str.length() && str[i]>='0' && str[i] <= '9')
	 		{
	 			temp.num = temp.num*10 + (str[i]-'0');
	 			i++;
			 }
			 q.push(temp);
		 }
		 else{   //如果不是数字，push到栈s 
		 	temp.flag = false;//标记是操作符
		 	//该操作符比栈顶元素优先级高的话，push进栈
			// 如果小于或等于栈顶元素优先级，则把栈顶元素送入后缀表达式队列 ，直到优先级比栈顶元素高 
			while(!s.empty() && op[str[i]] <= op[s.top().op]) 
			{
				q.push(s.top());   // 栈顶结构体入栈到q中 
				s.pop();			//删除栈顶元素 
			}
			temp.op = str[i];
			s.push(temp);
			i++; 
		 }
	 }
	 
	 //for循环结束后，操作符栈还有一个操作符，弹到后缀表达式中
	 while(!s.empty())
	 {
	 	q.push(s.top());
	 	s.pop();	 	
	  } 
}


double Cal(){   //计算后缀式 
	double temp1,temp2;
	node cur,temp;
	//s栈现在是空的，可以用来存储操作数 
	while(!q.empty()){
		cur = q.front();  //记录队首元素 
		q.pop(); 		  //记录就删除
		if(cur.flag==true) s.push(cur);   //如果是操作数，直接压入栈
		else{   //如果是操作符 ，就弹出两个s栈元素，参与运算 
		temp2 = s.top().num;
		s.pop(); //读出就删除
		temp1 = s.top().num;
		s.pop();
		temp.flag = true;  // 临时记录操作数，之后还要继续存入s栈 
		if(cur.op == '+') temp.num = temp1 + temp2;   	   //加法 
		else if(cur.op == '-') temp.num = temp1 - temp2;   //减法 
		else if(cur.op == '*') temp.num = temp1 * temp2;   //乘法
		else if(cur.op == '/') temp.num = temp1 / temp2;   //除法 
		s.push(temp); 
		} 
		
	}
	return s.top().num;  //栈顶元素就是后缀表达式的值 
	
}

int main(){
	op['+'] = op['-'] = 1;
	op['*'] = op['/'] = 2;  //映射，乘除优先级高 
	
	while(getline(cin,str),str != "0"){
		for(int i = 0;i < str.size();i++)
		{
			if(str[i] == ' ') str.erase(str.begin() + i);  //把表达式中的 0 去除 
		}
		while(!s.empty()) s.pop(); 		 //初始化栈
		Change(); 					  	 //将中缀表达式转为后缀表达式
		printf("%.2f\n",Cal());   		 //计算后缀表达式 
	}
	
	return 0; 
	
}