C/C++的中缀转后缀并求值的实现

简单的中缀转后缀并求值的C/C++实现

中缀转后缀

Description

输入一个中缀算术表达式S，S中的操作数为0到9，只含+，-和*，/运算，也可能含有括号()，运算符的计算顺序和实际四则运算的计算顺序相同. 请输出与S等价的后缀表达式，注意输出结果不要含有多余的括号或空格.

Input

输入有多组数据.

每组数据是一个中缀表达式S，S的长度不超过50. 输入的S保证合法，而且不包含多余的空格或制表符.

输入以#号结束.

Output

对于每个中缀表达式，输出转换后的后缀表达式，每个输出占一行.

Sample Input

1

1+2*3

(1-2)/3

#

Sample Output

1

123*+

12-3/

话不多说，直接贴代码，具体分析见上一篇博客

#include <iostream>
#include <stdlib.h>
#include <string>
#include <stack>

using namespace std;

bool isBetter(char a, char b) {
if ((a == '*' || a == '/') && (b == '+' || b == '-')) return true;
return false;
}

int main() {
string input;
while(1) {
cin >> input;
if (input[0] == '#') break; // 判断是否结束
int l = input.size();
stack<char> op;
for (int i = 0; i <= l; i++) {
if (i != l) { // 判断是否到达结尾
// 如果是数字，则直接输出
if (input[i] >= '0' && input[i] <= '9') {
cout << input[i];
} else {
// 如果栈为空或者是左括号，直接入栈
if (op.empty() || input[i] == '(') {
op.push(input[i]);
} else if (input[i] == ')'){
// 如果时右括号，则将栈输出，直到遇到一个左括号
while(!op.empty() && op.top() != '(') {
cout << op.top();
op.pop();
}
op.pop();// 将左括号弹出不输出
} else {
// 如果是运算符，则比较其与栈顶运算符的优先级
while (!op.empty()) {
if (isBetter(input[i], op.top())) { // 如果优先级高，则入栈
break;
} else { // 如果优先级低，则输出栈顶，将当前运算符入栈
if (op.top() != '(') { // 确保栈顶不是左括号，左括号仅在读到右括号时处理
cout << op.top();
op.pop();
} else {
break;
}
}
}
op.push(input[i]); // 将当前运算符入栈
}
}
} else { // 将剩下的操作符输出
while (!op.empty()) {
cout << op.top();
op.pop();
}
}
}
cout << endl;
}
return 0;
}

计算中缀表达式的值

本题目将上面的转换封装为函数，并做了适当的处理以将不同的运算数分开

Description

输入中缀算术表达式S，S中的操作数为非负整数，只含+，-和*，/运算，也可能含有括号()，运算符的计算顺序和实际四则运算的计算顺序相同. 输出表达式S的值. 注意除法运算只取整数部分，例如1/2=0.

Input

输入有多组数据.

每组数据是一个算术表达式S，S的长度不超过100. 输入的S保证合法，而且不包含多余的空格或制表符. S的操作数、中间结果和最终结果都不会超过int类型的范围，也不会出现除数为0的情况.

输入以#号结束.

Output

对于每个算术表达式S，输出S的值，每个输出占一行.

Sample Input

1

478+522

(478+522)*10

1/2-1

#

Sample Output

1

1000

10000

-1

#include <iostream>
#include <stack>

using namespace std;

bool isBetter(char a, char b);
string toPostifix(string input);
int calculate(int x, int y, char t_op);
int main() {
string input, postfix;
while (1) {
// 运用后缀表达式，遇到数字是入栈，遇到运算符时，从栈中取出并弹出两个数进行运算，将其运算结果压入栈中
cin >> input;
if (input[0] == '#') break;
postfix = toPostifix(input); // 转成后缀表达式，用.将数字和操作符间隔开
int ll = postfix.size();
int tmpNum = 0;
int mark = 0; // 用来标记是否输出是单个数字的情况
stack<int> num;
for (int i = 0; i < ll; i++) {
if (postfix[i] == '.') { // 如果读到. 则将读取到的数入栈
if (tmpNum != 0) {
int x = tmpNum;
num.push(x);
tmpNum = 0;
mark = 1;
}
} else {
// 如果遇到的是数字，则逐步将其转成int
if (postfix[i] >= '0' && postfix[i] <= '9') {
tmpNum = tmpNum*10+postfix[i]-'0';
mark = 2;
} else {
// 遇到数字后面没有.而是操作符的情况下，也要将数字提取出来入栈
if (mark == 2) {
int x = tmpNum;
num.push(x);
tmpNum = 0;
mark = 1;
}
// 遇到运算符，计算出新的值，然后入栈
int num1 = num.top();
num.pop();
int num2 = num.top();
num.pop();
int ans = calculate(num2, num1, postfix[i]);
num.push(ans);
}
}
}
if (mark == 2) {
cout << tmpNum << endl;
} else if (!num.empty()) {
cout << num.top() << endl;
}
}
return 0;
}

bool isBetter(char a, char b) {
if ((a == '*' || a == '/') && (b == '+' || b == '-')) return true;
return false;
}

int calculate(int x, int y, char t_op) {
if (t_op == '+') return x+y;
if (t_op == '-') return x-y;
if (t_op == '*') return x*y;
return x/y;
}
string toPostifix(string input) {
string tmp = "";
int l = input.size();
stack<char> op;
for (int i = 0; i <= l; i++) {
if (i != l) { // 判断是否到达结尾
// 如果是数字，则直接输出
if (input[i] >= '0' && input[i] <= '9') {
tmp += input[i];
} else {
tmp += '.';
// 如果栈为空或者是左括号，直接入栈
if (op.empty() || input[i] == '(') {
op.push(input[i]);
} else if (input[i] == ')'){
// 如果时右括号，则将栈输出，直到遇到一个左括号
while(!op.empty() && op.top() != '(') {
tmp += op.top();
op.pop();
}
op.pop();// 将左括号弹出不输出
} else {
// 如果是运算符，则比较其与栈顶运算符的优先级
if (isBetter(input[i], op.top())) { // 如果优先级高，则入栈
op.push(input[i]);
} else { // 如果优先级低，则输出栈顶，将当前运算符入栈
if (op.top() != '(') { // 确保栈顶不是左括号，左括号仅在读到右括号时处理
tmp += op.top();
op.pop();
}
op.push(input[i]); // 将当前运算符入栈
}
}
}
} else { // 将剩下的操作符输出
while (!op.empty()) {
tmp += op.top();
op.pop();
}
}
}
return tmp;
}