中序转逆波兰式

#include <stack>
#include<iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
//先给运算符设置优先级  + -设置为1  * /设置为2  #设置为0 因为#是一开始放进去的 
int precede(char a) {
	switch (a)
	{
	case '+':
		return 1;
	case '-':
		return 1;
	case '*':
		return 2;
	case '/':
		return 2;
	case '#':
		return 0;
	case '(':
		return -1;
	}
}
 //比较表达式中的元素与栈中元素的优先级   判断表达式中元素的优先级别是否大于栈中元素的优先级
bool comparePrecde(char a,char b) {  //前表达式中的元素 后栈中的元素
	int pre_a = precede(a);
	int pre_b = precede(b);
 
	if (pre_a > pre_b) {
		return true;
	}
	else {
		return false;
	}
}
 
int main() {
 
	stack<char> numStack;  //用来存储数字
	stack<char> exprStack;  //用来存储表达式
	stack<char> tempStack;  //暂时存储
	stack<float> resStack;  //用来存储计算结果
	vector<char> opVec;   //正序输出
	exprStack.push('#');     //先将#作为初始值输入到表达式中
 
	string buffer;   //用来读取中缀表达式
	cin >> buffer;  //键盘输入中缀表达式
	for (int i = 0; i < buffer.size(); ++i) {   //数字和运算符分离
		if (isdigit(buffer[i])) {
			numStack.push(buffer[i]);//将数字输入数字栈
		}
		else if(buffer[i]=='(')	{
			exprStack.push(buffer[i]);
		}
		 else if(buffer[i]==')'){
		 	while(exprStack.top()!='('){
				numStack.push(exprStack.top());
				exprStack.pop();
			}
			exprStack.pop();//将那个'('排出去
		 }
		else{
		
			while (!comparePrecde(buffer[i], exprStack.top())) {
				numStack.push(exprStack.top());//小于的话就将符号栈的栈顶元素输入到数字栈中去
				exprStack.pop();
			}

		


			//直到当前的符号比符号栈的元素优先级大为止
			exprStack.push(buffer[i]);
		}
	}
	
	while (exprStack.top() != '#') {     //剩余的元素压入栈
		numStack.push(exprStack.top());  //将剩余的元素全部压入到数字栈中去
		exprStack.pop();
	}
	
	while (!numStack.empty()) {
		opVec.push_back(numStack.top());  //将数字栈中的元素输出
		tempStack.push(numStack.top());
		numStack.pop();
	}
	
	reverse(opVec.begin(), opVec.end());  //输出逆波兰式列 
	for (auto x : opVec) {
		cout << x;
	}
 
	cout << endl;
	//计算结果
	while (!tempStack.empty()) {
		if (isdigit(tempStack.top())) {
			 #include <stack>
  2 #include<iostream>
  3 #include <string>
  4 #include <vector>
  5 #include <algorithm>
  6 using namespace std;
  7 //先给运算符设置优先级  + -设置为1  * /设置为2  #设置为0 因为#是一开始放进去的 
  8 int precede(char a) {
  9         switch (a)
 10         {
 11         case '+':
 12                 return 1;
 13         case '-':
 14                 return 1;
 15         case '*':
 16                 return 2;
 17         case '/':
 18                 return 2;
 19         case '#':
 20                 return 0;
 21         case '(':                                                                                                                                                                                       
 22                 return -1;
 23         }
 24 }
 25  //比较表达式中的元素与栈中元素的优先级   判断表达式中元素的优先级别是否大于栈中元素的优先级
 26 bool comparePrecde(char a,char b) {  //前表达式中的元素 后栈中的元素
 27         int pre_a = precede(a);
 28         int pre_b = precede(b);
 29 
 30         if (pre_a > pre_b) {
 31                 return true;
 32         }
 33         else {
 34                 return false;
 35         }
 36 }
 37 
 38 int main() {
 39 
 40         stack<char> numStack;  //用来存储数字
 41         stack<char> exprStack;  //用来存储表达式
 42         stack<char> tempStack;  //暂时存储
 43         stack<float> resStack;  //用来存储计算结果
 44         vector<char> opVec;   //正序输出
 45         exprStack.push('#');     //先将#作为初始值输入到表达式中
 46 
 47         string buffer;   //用来读取中缀表达式
 48         cin >> buffer;  //键盘输入中缀表达式
resStack.push((float)(tempStack.top() - '0'));  //char to int
			tempStack.pop();
		}
		else {
			char expr = tempStack.top();
			tempStack.pop();
			float a = resStack.top();
			resStack.pop();
			float b = resStack.top();
			resStack.pop();
 
			switch (expr)
			{
			case'+':
				resStack.push(b + a);
				break;
			case'-':
				resStack.push(b - a);
				break;
			case'*':
				resStack.push(b * a);
				break;
			case'/':
				resStack.push(b / a);
				break;
			}
		}
	}
	cout << resStack.top() << endl;   //输出结果
	return 0;
}

(base) zouyong@zz:~/TEST/逆波兰式求值/study/reverseOr$ ./app
1*(1+2) 
112+*
3
(base) zouyong@zz:~/TEST/逆波兰式求值/study/reverseOr$ ./app
1*(2+1)+1
121+*1+
4
(base) zouyong@zz:~/TEST/逆波兰式求值/study/reverseOr$ ./app
(2+1)*2-1
21+2*1-
5