后缀表达式求值:
原题链接:leetcode 150. 逆波兰表达式求值
关键词: 表达式树、后缀表达式
根据 逆波兰表示法,求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数,也可以是另一个逆波兰表达式。
说明:
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说,表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1:
输入:tokens = ["2","1","+","3","*"]
输出:9
解释:该算式转化为常见的中缀算术表达式为:((2 + 1) * 3) = 9
示例 2:
输入:tokens = ["4","13","5","/","+"]
输出:6
解释:该算式转化为常见的中缀算术表达式为:(4 + (13 / 5)) = 6
示例 3:
输入:tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出:22
解释:
该算式转化为常见的中缀算术表达式为:
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22
提示:
1 <= tokens.length <= 104
- tokens[i] 要么是一个算符(“+”、“-”、“*” 或 “/”),要么是一个在范围 [-200, 200] 内的整数
补充:
逆波兰表达式是一种后缀表达式,所谓后缀就是指算符写在后面。
平常使用的算式则是一种中缀表达式,如 ( 1 + 2 ) * ( 3 + 4 )
。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )
。
逆波兰表达式主要有以下两个优点:
- 去掉括号后表达式无歧义,上式即便写成
1 2 + 3 4 + *
也可以依据次序计算出正确结果。 - 适合用栈操作运算:遇到数字则入栈;遇到算符则取出栈顶两个数字进行计算,并将结果压入栈中。
思路:
逆波兰表达式是后缀表达式,也是表达式树的后序遍历。表达式树的数字都在叶子结点,运算符都在中间结点。在逆波兰表达式中对于一个运算符来说,它的左右子树就是他前面的两个数。
用一个栈来存储数字,遍历逆波兰表达式,如果遇到数字就入栈,遇到操作符就从栈中取出头两个数进行对应的操作,最终栈里剩下的数就是最后的结果。
例如:
逆波兰表达式:3 2 + 1 *
先把3和2分别入栈,遇到+
,将3和2取出,运算完将结果5入栈;
此时的表达式:5 1 *
;
再将5和1分别入栈, 遇到*
,将5和1取出,运算完将结果5入栈;
最终栈里剩下的数5也就是最终结果。
代码实现:
class Solution {
public:
stack<int> stk;
void eval(string s){ //s是操作符
int b = stk.top(); stk.pop(); //注意a b是反着取的
int a = stk.top(); stk.pop();
if(s == "+") stk.push(a + b);
else if(s == "-") stk.push(a - b);
else if(s == "*") stk.push(a * b);
else stk.push(a / b);
}
int evalRPN(vector<string>& tokens) {
unordered_set<string> se{"+", "-", "*", "/"};
for(auto &s:tokens) {
if(se.count(s)) eval(s);
else stk.push(stoi(s));
}
return stk.top();
}
};
表达式求值:
题目链接: AcWing 3302. 表达式求值
关键词: 表达式树、中缀表达式求值、模板题
给定一个表达式,其中运算符仅包含 +
、-
、*
、/
(加 减 乘 整除),可能包含括号,请你求出表达式的最终值。
注意:
- 数据保证给定的表达式合法。
- 题目保证符号 - 只作为减号出现,不会作为负号出现,例如,-1+2,(2+2)*(-(1+1)+2) 之类表达式均不会出现。
- 题目保证表达式中所有数字均为正整数。
- 题目保证表达式在中间计算过程以及结果中,均不超过 231−1。
- 题目中的整除是指向 0 取整,也就是说对于大于 0 的结果向下取整,例如 5/3=1,对于小于 0 的结果向上取整,例如 5/(1−4)=−1。
C++和Java中的整除默认是向零取整;Python中的整除//默认向下取整,因此Python的eval()函数中的整除也是向下取整,在本题中不能直接使用。
输入格式
共一行,为给定表达式。
输出格式
共一行,为表达式的结果。
数据范围
表达式的长度不超过 105。
输入样例:
(2+2)*(1+1)
输出样例:
8
中缀表达式和后缀表达式求值的主要区别:
- 中缀表达式需要考虑到符号的优先级,需要有括号。后缀表达式不需要
- 中缀表达式需要一个栈来存放运算符。后缀不需要
怎么判断一个子树已经遍历完?
当前运算符的优先级 <= 上一个运算符的优先级
例如,读到+
时,+
优先级比*
低,此时就可确定左子树已经遍历完,可以执行*
的操作
括号怎么处理?
括号单独处理:
读到左括号(
,就正常入栈;
读到右括号)
,此时需要把括号内的部分运算完成,从右往左(也就是从栈顶往下) 依次运算,直到读到(
为止
代码实现:
#include <iostream>
#include <cstring>
#include <stack>
#include <algorithm>
#include <unordered_map>
using namespace std;
unordered_map<char, int> pr{{'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}};
stack<int> nums; // 存数
stack<char> ops; // 存操作
// 执行操作栈栈顶的操作 处理数字栈栈顶两个数
void eval(){
// a、b的顺序不能还
auto b = nums.top(); nums.pop();
auto a = nums.top(); nums.pop();
auto c = ops.top(); ops.pop();
int x = 0;
if(c == '+') x = a + b;
else if(c == '-') x = a - b;
else if(c == '*') x = a * b;
else x = a / b;
nums.push(x);
}
int main(){
string str;
cin >> str;
for(int i = 0; i < str.size(); i ++ ){
auto c = str[i];
// 是数字
if(isdigit(c)){
int x = 0, j = i;
while(j < str.size() && isdigit(str[j])){
x = x * 10 + str[j] - '0';
j++;
}
i = j - 1; // i回到j的位置
nums.push(x);
}
else if(c == '(') ops.push(c);
else if(c == ')'){
while(ops.top() != '(') eval();
ops.pop(); //去掉左括号
}
// 普通符号
else{
// 当前符号优先级小于等于栈顶操作 执行栈顶操作 当前操作入栈
while(ops.size() && pr[c] <= pr[ops.top()]) eval();
ops.push(c);
}
}
// 剩余操作都执行完
while(ops.size()) eval();
cout << nums.top() << endl;
return 0;
}
中缀表达式转后缀表达式:
#include<iostream>
#include<unordered_map>
#include<vector>
#include<algorithm>
#include<unordered_set>
#include<stack>
using namespace std;
// ops存操作符 priority存优先级
stack<string> ops;
unordered_map<string, int> priority = {{"(",0},{"+", 1}, {"-", 1}, {"*", 2}, {"/", 2}};
string ans;
/*********************中缀表达式转后缀表达式********************************/
/*
* 转化规则:
* 从左到右遍历字符串 数字直接输出
* 遇到左括号进栈
* 遇到运算符号,若栈顶符号的优先级较低,则该符号进栈,若栈顶优先级不低于当前符号,则将栈顶符号弹出到vstr中, 再次比较栈顶和新符号优先级....循环比较,直到当前符号的优先级大于栈顶符号的优先级
* 遇到右括号,将栈顶符号依次弹出并加入vstr中, 直到碰到匹配的左括号
* 遍历结束之后:将栈顶所有的符号弹出加入vstr中
*/
//根据上面的转化规则进行转化
string convert(string &s){
// 从左到右遍历字符
for(int i = 0; i < s.size(); ++i){
string str;
// 如果当前字符是数字
if(isdigit(s[i])){
// 扣出数字
while(i < s.size() && isdigit(s[i])) str += s[i++];
ans += str;
// 提前退出
if(i == s.size())
break;
}
// 如果是左括号
if(s[i] == '(')
ops.push("(");
// 如果是右括号
else if(s[i] == ')'){
// 从栈中依次取出操作符 直到遇到左括号为止
while(ops.size()){
auto item = ops.top(); ops.pop();
// 左括号就退出, 其余操作符输出
if(item == "(" )
break;
else
ans += item;
}
}
// 运算符的情况
else{
// 当前字符的优先级
int s_pr;
if(s[i] == '-' || s[i] == '+') s_pr = 1;
else s_pr = 2;
while(ops.size()){
auto item = ops.top();
// 如果当前优先级 <= 栈顶操作符优先级
if(s_pr <= priority[item]){
ans += item;
ops.pop();
}
else
break;
}
ops.emplace(1, s[i]);
}
}
// 如果最后栈中还有操作符 依次输出即可
while(ops.size()){
auto item = ops.top(); ops.pop();
ans += item;
}
return ans;
}
auto main() -> int
{
string s; cin >> s;
cout << convert(s) << endl;
return 0;
}