后缀表达式转化为前缀表达式并求值

合集下载

第二章前缀表达式、中缀表达式、后缀表达式的转换

Stack
* （ +
a b c
Outpu t
* + d e
a+b*c+（d*e+f）*g
11. 读到“+”，弹出“*”并输出，然后将“+”压入栈中。 12.读到f，直接输出。此时栈和输出的情况如下：
Stack
* （ +
a b c * +d e * f
Outpu t
a+b*c+（d*e+f）*g
Stack
++ a * b c * + * d e f g
Outpu t
任务二：将下列中缀表达式转换为前缀表达式
中缀表达式前表达式
• 1+（（2+3）*4）-5 • a-（b + c/d）*e • a + b*（c + d/e） • a*（b + c）-d
•？ •？ •？ •？
思考
中缀表达式到前缀表达式、后缀表达式是否还有其他的转换方法？
Stack
* +
a b c
Outpu t
a+b*c+（d*e+f）*g
6.读到“+”，因为栈顶元素“*”优先级比“+”高，所以弹出“*” 并输出，同理，栈中下一个元素“+”优先级与读到的操作符“+”一样，所以也要弹出并输出。然后再将读到的“+”压入栈中。
此时栈和输出的情况如下：
Stack
+
a b c
前缀表达式的计算机求值举例
前缀表达式“-*+3456” （1）从右至左扫描，将6、5、4、3压入堆栈；（2）遇到+运算符，因此弹出3和4（3为栈顶元素、4为次顶元素），计算出3+4的值，得7，再将7入栈；

后缀表达式转前缀表达式的规则

后缀表达式转前缀表达式的规则后缀表达式（也称为逆波兰表达式）是一种不需要括号的表达式表示方式，通过在操作符号后面输入操作数来表示操作的顺序。

前缀表达式（也称为波兰表达式）则是将操作符号放在操作数前表示操作顺序。

在实际计算中，后缀表达式更为常用，因为它可以通过栈的方式快速计算，而前缀表达式需要反向扫描以计算数值。

然而，在一些情况下，需要将后缀表达式转换成前缀表达式，以下是该过程的规则。

规则1：倒序读取后缀表达式要将后缀表达式转换成前缀表达式，需要先倒序读取后缀表达式（也就是从右向左读取）。

例如，对于后缀表达式“3 5 + 2 *”，倒序读取为“* 2 + 5 3”。

规则2：将操作数压入栈中在倒序读取后缀表达式时，遇到操作数（也就是数字）就将其压入栈中。

例如，在“* 2 + 5 3”中，遇到“2”、“5”、“3”时，将其压入栈中。

规则3：遇到操作符时，出栈两个操作数当遇到操作符时，需要从栈中出栈两个操作数进行计算，并将结果压入栈中。

例如，在“* 2 + 5 3”中，遇到“+”时，需要出栈操作数“5”和“3”进行加法计算，并将结果“8”压入栈中。

规则4：生成前缀表达式在倒序读取后缀表达式并执行相应操作后，最终得到了一个栈，栈顶元素即为前缀表达式的起始点。

例如，在执行“* 2 + 5 3”的转换后，得到的栈中只有一个元素“* + 5 3 2”，即为转换后的前缀表达式。

举例来说，考虑转换后缀表达式“2 3 * 4 +”。

按照上述规则进行转换：1. 倒序读取：+ 4 * 3 22. 操作数入栈：[4]3. 操作数入栈：[4, 2]4. 乘法计算：[6]5. 加法计算：[10]6. 得到的前缀表达式为“+ * 3 2 4”。

需要注意的是，当表达式中存在多个操作数时，需要在操作数之间添加空格，以便在倒序读取后可以正确地将操作数区分开。

总结后缀表达式转前缀表达式可以通过将后缀表达式反向读取，同时使用栈的方式进行计算，最终得到前缀表达式。

“中序表达式”转换为“前序表达式”、“后序表达式”

“中序表达式”转换为“前序表达式”、“后序表达式” 上周末参照书本写了个“计算器”的程序，其中最令我费解的就是“前序表达式”、“后续表达式”，好像记得⽼师在上课的时候讲过，估计当时也没听懂，看的稀⾥糊涂的，不过现在⼤概明⽩了…… 在此仅做以笔记。

⾸先看下⾯所⽰表格：中序表达式2*3/(2-1)+3*(4-1)前序表达式+/*23-21*3-41后序表达式23*21-/341-*+ 中序表达式对我们⽽⾔是很直观的（我们平时接触的就是这个），但计算机处理起来⽐较⿇烦（括号、优先级之类的），前序和后序表达式中没有括号，⽽且在计算中只需单向扫描，不需要考虑运算符的优先级。

以前序表达式“+/*23-21*3-41”为例，从右往左，先取出两个操作数“1”、“4”和⼀个运算符“-”，计算“4-1”，将结果3回填到字符串中，现在字符串变为“+/*23-21*33”。

再从右⾄左取两个数“3”、“3”和“*”，计算“3*3”，将结果“9”回填到字符串，得“+/*23-219’”, 再取数，连续取出“9”、“1”、“2”，直到取出⼀个运算符“-”，将与运算符最近的两个操作数进⾏计算，即“2-1”得“1”，回填字符串中，现在为“+/*239” 重复上述步骤，取出“2*3”=6，回填字符串得到“+/619”，再取“6/1”=6，得到“+69”, 再取“6+9”=15。

运算完毕。

即从右⾄左取数，直到取出⼀个运算符，将刚取出的紧挨着运算符的两个操作数按运算符进⾏计算，结果回填⾄运算符。

重复该步骤，直到最后只剩下⼀个字符串则剩下的字符串即为结果。

后序表达式的字符串扫描⽅式正好和前序相反，是从左往右扫描，规则类似。

中序表达式转前序表达式步骤1、反转输⼊字符串，如“2*3/(2-1)+3*(4-1)” 反转后为“ )1-4(*3+)1-2(/3*2”，2、从字符串中取出下⼀个字符 2.1.如果是操作数，则直接输出 2.2.如果是“)”，压⼊栈中 2.3.如果是运算符但不是“(”，“)”,则不断循环进⾏以下处理 2.3.1.如果栈为空，则此运算符进栈，结束此步骤 2.3.2.如果栈顶是“)”,则此运算符进栈，结束此步骤 2.3.2.如果此运算符与栈顶优先级相同或者更⾼，此运算符进栈，结束此步骤 2.3.4.否则，运算符连续出栈，直到满⾜上述三个条件之⼀，然后此运算符进栈 2.4、如果是“(”，则运算符连续出栈，直到遇见“)”为⽌,将“)”出栈且丢弃之3、如果还有更多的字符串，则转到第2步4、不在有未处理的字符串了，输出栈中剩余元素5、再次反转字符串得到最终结果我第⼀次看到这个的时候就没看懂是什么意思，在⽹上查了点，⼜瞪了它好久才明⽩了，就以“2*3/(2-1)+3*(4-1)，”为例做以下说明： 2*3/(2-1)+3*(4-1)，反转得“ )1-4(*3+)1-2(/3*2 ”；取第⼀个字符串为“）”，⼊栈（此时栈中为“）”）；取下⼀个“1”，是操作数，直接输出（⽬前输出“1”）；取下⼀个“-”，既不是“)”,也不是“（”，则转到2.3，此时栈顶为“）”,则该运算符进栈（栈中为“-、）”）；取下⼀个“4”，直接输出（⽬前输出的是“14”）；取下⼀个“(”，运算符连续出栈（栈中此时为“-、）”），直到遇见“)”,此时输出“-”（⽬前输出“14-”，栈为空）；取下⼀个“*”，既不是“)”,也不是“（”，则转到2.3，进栈（栈为空）；取下⼀个“3”，直接输出（⽬前输出“14-3”）；取下⼀个“+”，此时栈顶为“*”,“+”的优先级⽐“*”低（2.3.4），则运算符连续出栈（只有⼀个*出栈，此时栈为空符合2.3.1，继续下⼀步），“+”进栈；取下⼀个“)”，进栈（此时栈中为“）、+”）；取下⼀个“1”直接输出（⽬前输出为14-3*1）；取下⼀个“-”，此时栈顶为“）”，“-”进栈（栈中此时为“-、）、+”）；取下⼀个“2”，直接输出（⽬前输出“14-3*12”）；取下⼀个“（”，运算符连续出栈，直到遇见“）”，此时栈中为“-、）、+”，输出-，且抛弃“）”，此时输出为“14-3*12-”,栈中为“+”；取下⼀个“/”，优先级⽐栈顶“+”⾼，此运算符进栈；取下⼀个“3”，直接输出（此时输出“14-3*12-3”）；取下⼀个“*”，优先级⽐栈顶“+”⾼，此运算符进栈；取下⼀个“2”，输出（此时输出“14-3*12-32”）；不在有未处理的运算符，输出栈中剩余元素,结果的“14-3*12-32*/+”；反转字符串的“+/*23-21*3-41”。

中缀表达式转换为前缀表达式

中缀表达式转换为前缀表达式中缀表达式转换为前缀表达式在《》中，我们讨论了对前缀表达式如何计算：设置⼀个操作数栈，对前缀表达式从右到左扫描，遇到操作数直接⼊栈，遇到操作符则从操作数栈弹栈，先弹left值后弹right值，根据操作符进⾏相应的计算，并将计算结果压⼊到操作数栈中，最终将整个前缀表达式扫⾯完毕。

这时操作数栈中只有⼀个元素，该元素的值即为前缀表达式的值。

在《》中，我们讨论了如何将⼀个中缀表达式转换为其对应的后缀表达式。

其思想为：设置⼀个操作符栈，如果遇到操作数，则直接将操作数放进后缀表达式中，如果遇到⾮操作数，则：如果是左括号，则将左括号⼊栈；如果是右括号，则从操作符栈中将操作符弹栈，放⼊后缀表达式中，直⾄栈空或遇到栈中的左括号，并将左括号弹栈；如果是其他操作符，则⽐较其优先级与栈中操作符优先级情况，如果栈中的操作符的优先级⼤于等于当前操作符，则将栈中操作符弹栈，直⾄栈空，或栈中操作符优先级⼩于当前操作符的优先级，将当前操作符压栈。

当从左到右顺序扫描完整个中缀表达式后，检测操作符栈，如果⾮空，则依次弹栈，将弹出的操作符依次压⼊到后缀表达式中。

最终，得到中缀表达式对应的后缀表达式。

如果还想计算后缀表达式的值，则可以参考《》。

本⽂我们是讨论如何将中缀表达式转换为前缀表达式。

我们先给出中缀表达式转换前缀表达式的程序，然后再对程序进⾏相关讲解，之后在与中缀表达式转换后缀表达式的过程进⾏⽐较，分析其中的差异存在于哪⾥。

// 中缀表达式转换为前缀表达式#include <iostream>#include <vector>#include <string>#include <sstream>#include <map>#include <stack>#include <algorithm>using namespace std;void GetInfix(vector<string>& infix){infix.clear();string line;getline(cin, line);istringstream sin(line);string tmp;while (sin >> tmp){infix.push_back(tmp);}}// 初始化操作符void InitOperators(map<string, int>& opers){opers.clear();opers["("] = 100;opers[")"] = 900;opers["+"] = 100;opers["-"] = 100;opers["*"] = 200;opers["/"] = 200;}bool IsOperator(const string& op, const map<string, int>& opers){auto cit = opers.find(op);if (cit != opers.end()){return true;}else{return false;}}void InfixToPrefix(const vector<string>& infix, vector<string>& prefix, map<string, int>& opers){prefix.clear();stack<string> stk; // 操作符栈for (int i = infix.size() - 1; i >= 0; --i) // 从右到左扫描{if (!IsOperator(infix[i], opers)) // 如果是操作数{prefix.push_back(infix[i]);}else// 如果是操作符{if (infix[i] == ")") // 如果是右括号，则直接⼊栈{stk.push(infix[i]);}else if (infix[i] == "(") // 如果是左括号{// 依次弹出栈中的操作符，直⾄遇到右括号while (!stk.empty()){if (stk.top() == ")"){stk.pop();break;}else{prefix.push_back(stk.top());stk.pop();}}}else// 如果是其他操作符{while (!stk.empty() && stk.top() != ")" && opers[stk.top()] > opers[infix[i]]) // 栈顶操作符优先级⼤于当前操作符优先级{prefix.push_back(stk.top());stk.pop();}// 将当前操作符⼊栈stk.push(infix[i]);}}}// 检测操作符栈是否为空while (!stk.empty()){prefix.push_back(stk.top());stk.pop();}// 将prefix翻转reverse(prefix.begin(), prefix.end());return;}void Display(const vector<string>& fix){for (auto i = 0; i != fix.size(); ++i){cout << fix[i] << '';}cout << endl;}int main(){map<string, int> opers;InitOperators(opers);while (true){vector<string> infix, prefix;GetInfix(infix);Display(infix);InfixToPrefix(infix, prefix, opers);Display(prefix);cout << endl;}return0;}⾸先说明的是，我们的中缀表达式输⼊是⽤空⽩符间隔的，⽽没有对中缀表达式进⾏词法分析，对中缀表达式的词法分析可以参考《》。

C#算术表达式求值（后缀法），看这一篇就够了

C#算术表达式求值（后缀法），看这⼀篇就够了⼀、种类介绍算术表达式有三种：前缀表达式、中缀表达式和后缀表达式。

⼀般⽤的是中缀，⽐如1+1，前后缀就是把操作符移到前⾯和后⾯，下⾯简单介绍⼀下这三种表达式。

1、前缀表⽰法前缀表⽰法⼜叫波兰表⽰法，他的操作符置于操作数的前⾯（例：+ 1 2），是波兰数学家扬·武卡谢维奇1920年代引⼊的，⽤于简化命题逻辑。

因为我们⼀般认为操作符是在操作数中间的，所以在⽇常⽣活中⽤的不多，但在计算机科学领域占有⼀席之地。

⼀般的表⽰法对计算机来说处理很⿇烦，每个符号都要考虑优先级，还有括号这种会打乱优先级的存在，将使计算机花费⼤量的资源进⾏解析。

⽽前缀表⽰法没有优先级的概念，他是按顺序处理的。

举个例⼦：9-2*3这个式⼦，计算机需要先分析优先级，先乘后减，找到2*3，再进⾏减操作；化成前缀表⽰法就是：- 9 * 2 3，计算机可以依次读取，操作符作⽤于后⼀个操作数，遇到减就是让9减去后⾯的数，⽽跟着9的是乘，也就是说让9减去乘的结果，这对计算机来说很简单，按顺序来就⾏了。

2、中缀表⽰法这也就是我们⼀般的表⽰法，他的操作符置于操作数的中间（例：1 + 2），前⾯也说过这种⽅法不容易被计算机解析，但他符合⼈们的普遍⽤法，许多编程语⾔也就⽤这种⽅法了。

在中缀表⽰法中括号是必须有的，要不然运算顺序会乱掉。

3、后缀表⽰法后缀表⽰法⼜叫逆波兰表⽰法，他的操作符置于操作数的后⾯（例：1 2 +），他和前缀表⽰法都对计算机⽐较友好，但他很容易⽤堆栈解析，所以在计算机中⽤的很多。

他的解释过程⼀般是：操作数⼊栈；遇到操作符时，操作数出栈，求值，将结果⼊栈；当⼀遍后，栈顶就是表达式的值。

因此逆波兰表达式的求值使⽤堆栈结构很容易实现，且能很快求值。

注意：逆波兰记法并不是简单的波兰表达式的反转。

因为对于不满⾜交换律的操作符，它的操作数写法仍然是常规顺序，如，波兰记法/ 6 3的逆波兰记法是6 3 /⽽不是3 6 /；数字的数位写法也是常规顺序。

前缀、中缀、后缀表达式的相互转换方法

前缀、中缀、后缀表达式的相互转换⽅法前缀式、中缀式、后缀式相互转换⼀. 中缀式转化成前缀式和后缀式：⼀个中缀式到其他式⼦的转换⽅法这⾥我给出⼀个中缀表达式a +b *c - (d +e )第⼀步：按照运算符的优先级对所有的运算单位加括号式⼦变成：( ( a + ( b * c ) ) - ( d + e ) )第⼆步：转换前缀与后缀表达式中缀转前缀：把运算符号移动到对应的括号前⾯则变成：- ( + ( a * ( b c ) ) + ( d e ) )把括号去掉：- + a * b c + d e 前缀式⼦出现中缀转后缀：把运算符号移动到对应的括号后⾯则变成：( ( a ( b c ) * ) + ( d e ) + ) -把括号去掉：a b c * + d e + - 后缀式⼦出现⼆. 前缀式转化成中缀式：+ a * b c + d e从后往前遇到运算符，将其与后⾯两个运算数结合，加上括号，当成新的运算数（例如：* b c 加上括号，变成 ( * b c )⼀个整体,作为运算数）变成：( - ( + a ( * b c ) ) ( + d e ) )将运算符加在括号内运算数中间。

变成：( ( a + ( b * c ) ) - ( d + e ) )去掉部分括号：a + b * c - ( d + e )（最后去掉的是不影响运算式含义的多余括号）三. 后缀式转化成中缀式：a b c * + d e + -从前往后遇到运算符，将其与前⾯两个运算数结合，加上括号，当成新的运算数变成：( ( a ( b c * ) + ) ( d e + ) - )将运算符加在括号内运算数中间。

变成：( ( a + ( b * c ) ) - ( d + e ) )去掉部分括号：a + b * c - ( d + e )（最后去掉的是不影响运算式含义的多余括号）。

前中后缀表达式的转化例题

前中后缀表达式的转化例题【最新版】目录1.前中后缀表达式的转化例题介绍2.前缀表达式的定义和性质3.中缀表达式的定义和性质4.后缀表达式的定义和性质5.表达式转换的方法和步骤6.表达式转换的实际应用案例正文一、前中后缀表达式的转化例题介绍前缀表达式、中缀表达式和后缀表达式是计算机科学中常见的三种表达式表示方法。

它们分别对应着不同的语法结构，具有各自的特点和应用场景。

在实际问题中，有时需要将一种表达式转换为另一种表达式，以便进行相应的操作和分析。

下面我们将通过一个具体的例题来介绍表达式转换的方法。

例题：将中缀表达式 "a + b" 转换为后缀表达式。

二、前缀表达式的定义和性质前缀表达式是一种特殊的二叉树，它的每个内部节点都有一个前缀，即该节点的左子树或右子树的一个路径。

前缀表达式的性质如下：1.前缀表达式只有一个根节点；2.每个节点只有一个前缀；3.前缀表达式的每个叶子节点对应一个变量；4.前缀表达式的每个节点对应一个运算符。

三、中缀表达式的定义和性质中缀表达式是另一种特殊的二叉树，它的每个内部节点都有一个中缀，即该节点的左子树、右子树或该节点本身。

中缀表达式的性质如下：1.中缀表达式只有一个根节点；2.每个节点可以有一个或多个中缀；3.中缀表达式的每个叶子节点对应一个变量；4.中缀表达式的每个节点对应一个运算符。

四、后缀表达式的定义和性质后缀表达式是一种特殊的二叉树，它的每个内部节点都有一个后缀，即该节点的左子树、右子树或该节点本身。

后缀表达式的性质如下：1.后缀表达式只有一个根节点；2.每个节点可以有一个或多个后缀；3.后缀表达式的每个叶子节点对应一个常数或变量；4.后缀表达式的每个节点对应一个运算符。

五、表达式转换的方法和步骤1.首先，根据中缀表达式构建一棵二叉树；2.遍历二叉树，将每个节点转换为对应的前缀表达式或后缀表达式；3.对于前缀表达式，遍历二叉树的每个节点，将该节点的左子树或右子树转换为前缀表达式，并将该节点对应的运算符添加到前缀表达式中；4.对于后缀表达式，遍历二叉树的每个节点，将该节点的左子树或右子树转换为后缀表达式，并将该节点对应的运算符添加到后缀表达式中；5.最后，将所有的前缀表达式或后缀表达式按照一定的顺序连接起来，得到最终的表达式。

C语言实现中缀、后缀、前缀表达式相互转化并求值

C语言实现中缀、后缀、前缀表达式相互转化并求值1.问题描述(1)表达式求值问题表达式是数据运算的基本形式。

人们的书写习惯是中缀式，如:11+22*(7-4)/3。

中缀式的计算按运算符的优先级及括号优先的原则，相同级别从左到右进行计算。

表达式还有后缀式(如:22 7 4 - * 3 / 11 +)和前缀式(如:+ 11 / * 22 –7 4 3)。

后缀表达式和前缀表达式中没有括号，给计算带来方便。

如后缀式计算时按运算符出现的先后进行计算。

本设计的主要任务是进行表达式形式的转换及不同形式的表达式计算。

2.数据结构设计(1)表达式求值问题由于表达式中有字符与数字两种类型，故定义结点一个标志域data，标志结点存储的为字符data=2还是数字data=1，再寻找结点中对应的存储位置，读取数字域data1,字符域data2。

而在前缀表达式时，存在表达式逆序，因表达式类型不统一，用栈逆序极不方便，选择构建双向链表，存储表达式。

typedef struct Node //定义存储中缀表达式的结点类型{int data;int data1;char data2;struct Node *next;}Lnode;typedef struct Node2 //定义存储前缀表达式的结点类型{int data;int data1;char data2;struct Node2 *next;struct Node2 *prior;}Lnode2;3.运行、测试与分析(1)表达式求值问题(1)按提示输入中缀表达式，如图1.1所示。

如输入中缀表达式不正确，提示输入有误，如图1.2,1.3所示。

图1.1图1.2图1.3(2)选择表达式转换并求值方式。

按“1”选择中缀表达式求值，如图1.4所示。

图1.4(3)按“2”选择中缀表达式转变为后缀表达式并求值，如图1.5所示。

图1.5(4)按“3”选择中缀表达式转变为前缀表达式并求值，如图1.6所示。

后缀表达式转换及求值

打印出后缀表达式
12，98，78，3，2，/，+，* , －
并算出正确结果
-7730 (注意：整数运算，3/2 =1 )
后缀表达式栈中元素结构的设计：
后缀表达式: 12，98，78，3，2，/，+，* , －
算子: 12，98，78，3，2 运算符号: +,-,*,/,*, ( , )
后缀表达式转换及求值
丁鑫 dingxin@
作业要求
实现一个将包含四则运算、括号的正整数表达式转换为后缀形式。
实现带括号的正整数的四则运算表达式的求值。要求能实现对多位整数进行处理的。
对错误格式的表达式进行判别并给出错误信息
示例
输入字符串：12 - 98*(78+3/2)
运算符优先关系矩阵
理解矩阵中函数返回值的含义
“#” ，程序中共出现两次，
输入字符串尾运算符栈的栈底，
“3”，出现1次
“(”可以压栈, “)”从不压栈
从中缀表达式求得后缀式的规则
(1) (2) (3) 设立操作符栈设表达式的结束符为“#”, 设运算符栈的栈底为“#”；当程序的出口是字符串的“#”遇到“#”，计算结束若当前字符串是个操作数则直接发送给后缀式。否则：若当前运算符的优先数高于栈顶运算符，则进栈；否则：退出栈顶运算符发送给后缀式； goto (3); (说明：循环伪码，尽量在实现上用goto语句) (4) “(” 对它之前后的运算符起隔离作用，“)”可视为自相应左括弧开始的表达式的结束符。相遇则自动取消。
计算后缀表达式
计运算符优先关系矩阵
“#”, 0,1,2,3,4含义不清楚，
尽量不要使用goto语句

前缀算术表达式转换及表达式计算

一、概述在数学运算中，算术表达式是一种描述数学运算的方式，常通过符号和数字的组合表示特定的计算过程。

前缀算术表达式是一种特殊的算术表达式，它的操作符位于操作数之前，例如"+ 3 4"表示加法运算，操作数为3和4。

前缀表达式的计算机实现在计算机科学和编程中具有广泛的应用。

本文将介绍前缀算术表达式的转换和表达式的计算方法。

二、前缀算术表达式转换1. 中缀表达式转前缀表达式中缀表达式是我们常见的数学表达式，例如"3 + 4 * 5"。

中缀表达式转前缀表达式的关键在于将操作符移动到操作数之前。

转换方法如下：- 从右向左遍历中缀表达式的每个字符。

- 如果是操作数，则直接输出。

- 如果是运算符，则与运算符栈顶的运算符比较优先级，如果优先级高于栈顶运算符，则入栈；否则弹出栈顶运算符并输出，直到满足条件入栈。

- 遍历完成后，弹出栈中所有运算符并输出，即得到前缀表达式。

中缀表达式"3 + 4 * 5"转换为前缀表达式为"+ 3 * 4 5"。

2. 后缀表达式转前缀表达式后缀表达式是操作数位于操作符之前的算术表达式，例如"3 4 + 5 *"。

后缀表达式转前缀表达式的方法如下：- 从左向右遍历后缀表达式的每个字符。

- 如果是操作数，则入栈。

- 如果是运算符，则弹出栈顶的两个操作数，并将运算符与操作数组合，得到新的前缀表达式，并将结果入栈。

- 遍历完成后，栈内剩下的元素即为前缀表达式。

后缀表达式"3 4 + 5 *"转换为前缀表达式为"* + 3 4 5"。

3. 中缀表达式转后缀表达式再转前缀表达式有时候，我们将中缀表达式转换为后缀表达式，然后再将后缀表达式转换为前缀表达式。

这种方法的具体步骤如下：- 将中缀表达式转换为后缀表达式。

- 将后缀表达式转换为前缀表达式。

这种方法的优点在于简化了中缀表达式到前缀表达式的转换过程。

中缀、前缀、后缀表达式的运算

中缀、前缀、后缀表达式的运算中缀表达式，就是在表达式中，操作符在操作数的中间，⽐如 (1+2)*3，+和*在1, 2, 3的中间。

前缀表达式，就是操作符在操作数的前⾯，⽐如 +12，+在1, 2的前⾯。

后缀表达式，就是操作符在操作数的后⾯，⽐如 12+，+在1, 2的后⾯。

为什么会有这么多表达式呢？它们⽬的不同。

中缀表达式，便于我们书写，也符合我们的阅读习惯，在计算机程序中，都是写中缀表达式，但它却不利于计算机进⾏算术计算，因为涉及到优先级和括号。

前缀表达式和后缀表达式中没有括号，并且运算符的优先级也通过它们在表达式中的顺序体现出来了，有利于计算机进⾏算术运算。

前缀表达式也叫波兰表达式，因为它是由⼀个波兰⼈发明的，相应的，后缀表达式也称为逆波兰表达式。

举个例⼦来说明⼀下三者的运算过程，假设计算(3+4)*5-6 使⽤中缀表达式进⾏计算 1，创建两个栈，⼀个是数字栈，⽤来存放操作数，⼀个是字符栈，⽤来存放操作符。

2，算术表达式是⼀个字符串，从左到右循环遍历表达式，依次取出每⼀个字符。

当取出的字符是操作数时，⼊数字栈。

当取出的字符是操作符时，这时还要看操作符的优先级和字符栈是否为空如果字符栈为空，直接把取出的字符放⼊到字符栈中。

如果字符栈不为空，则要⽐较字符的优先级如果取出的字符的优先级⼤于等于字符栈中栈顶的字符的优先级，直接把取出的字符放⼊到字符栈中。

如果取出的字符的优先级⽐字符栈中栈顶的字符的优先级低，则要循环进⾏如下操作，直到取出的字符的优先级⼤于等于字符栈中栈顶字符的优先级或者栈为空，此时，把取出的字符放⼊到字符栈中。

如下操作就是： 1，从字符栈中弹出操作符 2，从数字栈中弹出两个操作数。

3，操作数结合操作符进⾏计算，要注意操作数顺序，后⾯pop出的数在求值的表达式中是前⾯的操作数，尤其是在做减法的时候 4，计算出的值放⼊到数字栈。

为什么要⽐较操作符的优先级呢？因为要确定操作数属于哪个操作符，相邻两个操作符之间的数字是共享的。

C语言后缀表达式计算

一、设计思想计算算数表达式并求值，采取的共有两种方法：1.先将算数表达式转化为后缀表达式，然后对后缀表达式进行计算。

2.对算数表达式进行直接的计算。

第一种算法这种解决方案又分为两步：1.将表达式先转化为后缀表达式的字符串数组2.利用后缀表达式进行计算在转化过程中，第一，建立一个存符号的栈，和一个字符串数组，用来存放转化以后的表达式然后，对于得到的用户输入的字符串进行逐个的扫描，如果是数组或者小数点，则直接存放到数组中，并且在后面加入一个分隔符，如果是操作符，则和栈中的已存的进行比较，如果比栈中的操作符的优先级高，则直接入栈，如果优先级低或相等，则栈中元素出栈，存到字符串中，然后再次检查栈顶，直到栈中元素的优先级低于扫描操作符，则此操作符入栈，然后扫描下一个字符，直到遇到字符串的结束符号\0，扫描结束。

数组中存的就是后缀表达式。

得到后缀表达式后，进行计算，要用到数值栈。

首先要将字符表示的数字转化为浮点小数，然后进行扫描，遇到数值，放入栈中，遇到操作符，就从栈中取出两个数，进行计算后再放入栈中，扫描下一个，最后的计算结果就存到了栈中，直接取出栈内元素，就是计算的最后结果。

第二种算发首先要建立两个栈，一个用来存放操作符，一个用来存放数值。

开始对用户输入的字符串进行扫描，如果是数字字符或者小数点，则将字符转化为浮点数存到数栈里，如果是操作符，则观察符号栈，如果栈顶元素的优先级低于观察的操作符，则操作符入栈，如果栈顶元素的优先级高于或者等于观察的操作符，则从数值栈中取出两个浮点数，从符号栈中取出栈顶的操作符，然后进行相应的数值计算，所得的结果再存到数值栈中，重复这样的操作，直到符号栈中栈顶元素的优先级低于观察的操作符，则此操作符入栈，然后对下一个字符进行扫描。

如果是左括号，则不进行优先级的比较，直接入栈，入栈后优先级为-1。

如果是右括号，则从数值栈中取两个操作数，符号栈中取出一个符号，然后进行计算后得数放入数栈中，不断进行此类操作，直到从栈中取出的是左括号为止，左括号去掉，扫描下一个。

数据结构表达式求值实验报告

数据结构表达式求值实验报告一、实验目的本次实验的主要目的是通过实现表达式求值的程序，深入理解数据结构和算法在解决实际问题中的应用。

具体包括掌握栈这种数据结构的操作和使用，熟悉表达式的转换和计算过程，提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、实验原理表达式求值是程序设计中的一个常见问题，通常采用栈这种数据结构来实现。

表达式可以分为中缀表达式、后缀表达式和前缀表达式。

中缀表达式是我们日常使用的表达式形式，如“2 ＋3 4”，但直接对中缀表达式求值比较复杂。

而后缀表达式（如“2 3 4 ＋”）和前缀表达式（如“＋2 3 4”）求值相对简单。

因此，在实现表达式求值时，通常先将中缀表达式转换为后缀表达式，然后对后缀表达式进行求值。

转换过程中，使用两个栈，一个用于存储操作数，另一个用于存储运算符。

求值过程中，根据后缀表达式的特点，从左到右依次处理操作数和运算符，进行相应的计算。

四、实验步骤1、定义数据结构定义栈类，用于存储操作数和运算符。

定义一个结构体来表示操作数和运算符。

2、中缀表达式转后缀表达式从左到右扫描中缀表达式。

遇到操作数，直接输出。

遇到运算符，根据其优先级与栈顶运算符的优先级进行比较，决定入栈或出栈操作。

3、后缀表达式求值从左到右扫描后缀表达式。

遇到操作数，入栈。

遇到运算符，从栈中取出两个操作数进行计算，将结果入栈。

4、主函数输入中缀表达式。

调用转换函数和求值函数，输出计算结果。

五、实验代码｀｀｀cppinclude ＜iostream>include ＜stack>include ＜string>／／定义操作符的优先级int priority(char op) ｛if （op ＝＝＇＋＇｜｜ op ＝＝＇＇）return 1;if （op ＝＝＇＇｜｜ op ＝＝＇／＇）return 2;return 0;｝／／中缀表达式转后缀表达式std:：string infixToPostfix(std:：string infix) ｛std:：stack<char> opStack;std:：string postfix ＝＂＂；for （char c ： infix) ｛if （isdigit(c)）｛postfix ＋＝ c;｝ else if （c ＝＝＇（＇）｛｝ else if （c ＝＝＇）＇）｛while （！opStackempty(）＆＆ opStacktop(）！＝＇（＇）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpop(）；／／弹出＇（＇｝ else ｛while （！opStackempty(）＆＆ priority(opStacktop(））＞＝priority(c)）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpush(c)；｝｝while （！opStackempty(））｛postfix ＋＝ opStacktop(）；｝return postfix;｝／／后缀表达式求值int evaluatePostfix(std:：string postfix) ｛std:：stack<int> operandStack;for （char c ： postfix) ｛if （isdigit(c)）｛operandStackpush(c ＇0'）；｝ else ｛int operand2 ＝ operandStacktop(）；operandStackpop(）；int operand1 ＝ operandStacktop(）；operandStackpop(）；switch （c) ｛case ＇＋＇：operandStackpush(operand1 ＋ operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇／＇：operandStackpush(operand1 ／ operand2)；break;｝｝｝return operandStacktop(）；｝int main(）｛std:：string infixExpression;std:：cout ＜＜＂请输入中缀表达式: ＂；std:：cin ＞＞ infixExpression;std:：string postfixExpression ＝ infixToPostfix(infixExpression)；int result ＝ evaluatePostfix(postfixExpression)；std:：cout ＜＜＂表达式的计算结果为: ＂＜＜ result ＜＜ std:：endl;return 0;｝｀｀｀六、实验结果输入不同的中缀表达式，如“2 ＋3 4”“（ 2 ＋ 3 ）4”等，程序能够正确地将其转换为后缀表达式，并计算出结果。

前缀表达式的计算

前缀表达式的计算前⾯我们曾对后缀表达式做过讨论。

后缀表达式的计算过程是⾸先设定⼀个操作数栈，顺序扫描整个后缀表达式，如果遇到操作数，则将操作数压栈；如果遇到操作符，则从操作数栈中弹出相应的操作数进⾏运算，并将运算结果进⾏压栈。

当将整个后缀表达式扫描完毕时，操作数栈中应该只有⼀个元素，该元素的值即为后缀表达式的计算结果。

对于⼀个后缀表达式：1 2 3 + -其对应的前缀表达式为：-1 + 2 3前缀表达式的计算⽅法与后缀表达式的计算⽅法类似。

对前缀表达式从后向前扫描，设定⼀个操作数栈，如果是操作数，则将其直接⼊栈，如果是操作符，则从栈中弹出操作符对应的操作数进⾏运算，并将计算结果压栈。

直⾄从右到左扫描完毕整个前缀表达式，这时操作数栈中应该只有⼀个元素，该元素的值则为前缀表达式的计算结果。

具体前缀表达式的计算程序如下：1// 计算前缀表达式2 #include <iostream>3 #include <sstream>4 #include <vector>5 #include <stack>6 #include <string>7using namespace std;89void GetPrefix(vector<string>& prefix)10 {11 prefix.clear();12string line, tmp;13 getline(cin, line);14 istringstream sin(line);15while (sin >> tmp)16 {17 prefix.push_back(tmp);18 }19 }2021bool IsOperator(const string& op)22 {23return op == "+" || op == "-" || op == "*" || op == "/";24 }2526double CalPrefix(const vector<string>& prefix)27 {28double ret = 0.0;29 stack<double> opeStk;30for (int i = prefix.size() - 1; i >= 0; --i)31 {32if (!IsOperator(prefix[i]))33 {34 opeStk.push((double)atof(prefix[i].c_str()));35 }36else37 {38double a = opeStk.top();39 opeStk.pop();40double b = opeStk.top();41 opeStk.pop();42double c = 0.0;4344switch (prefix[i][0])45 {46case'+':47 c = a + b;48 opeStk.push(c);49break;5051case'-':52 c = a - b;53 opeStk.push(c);54break;5556case'*':57 c = a * b;58 opeStk.push(c);59break;6061case'/':62 c = a / b;63 opeStk.push(c);64break;6566default:67break;68 }69 }70 }7172if (opeStk.size() == 1)73 {74return opeStk.top();75 }76else77 {78return -1000000000.0;79 }80 }8182int main()83 {84 vector<string> prefix;85while (true)86 {87 GetPrefix(prefix);88 cout << CalPrefix(prefix) << endl << endl;89 }90return0;91 }。

前缀表达式、中缀表达式、后缀表达式的定义及实现

前缀表达式、中缀表达式、后缀表达式的定义及实现定义1. 中缀表达式：平常我们⼿动输⼊的表达式、计算式，都是中缀表达式，按照我们理解的运算优先顺序进⾏计算。

按照⼈的思维⽅式进⾏表达式的输⼊，最终输出预期结果。

⽐如 1 + (2 + 3) × 4 - 52. 后缀表达式、前缀表达式：虽然中缀表达式是按照我们⾁眼的运算符优先级写出的，但是最终实现这个运算的，⽐如计算器是没有这么智能的，计算器只会按照输⼊的运算符⼀个⼀个的进⾏计算。

这时候就⽤到了后缀、前缀表达式。

⽐如：后缀表达式针对于上⾯的就是 1 2 3 + 4 × + 5 -⼿动实现1. 那么我们怎么实现中缀转换为后缀呢？⼿动实现：把所有运算按照优先级加上括号，然后把运算符号移动到括号前⾯，然后去除括号。

⽐如：1 + (2 + 3) × 4 - 5加括号：1 +( (2 + 3) × 4 ) - 5(1 +( (2 + 3) × 4 )) - 5((1 +( (2 + 3) × 4 )) - 5)运算符号后移，并去除括号：1 2 3 + 4 × + 5 -前缀表达式，就是符号前移，⼀样的2.计算机怎么去识别后缀呢使⽤⼤名⿍⿍的栈就很⽅便的实现了栈的特点是先进后出，后进先出针对于后缀表达式1. 遇到数字⼊栈2. 遇到运算符，弹出栈的两个数字，然后和运算符进⾏运算3. 重复过程4. 因为后缀表达式，其实已经是把运算符优先级顺序换⼀种表⽰形式，展现出来了⽽已程序实现说了⼀⼤推，我们⾸先来看⼀下程序上的实现⼀个对中缀表达式进⾏输⼊，然后进⾏转换，并进⾏结果的输出步骤1. 中缀表达式转化为后缀表达式2. 进⾏后缀表达式的计算第⼀步程序思路:1. 定义栈S1，存储运算符。

定义栈S2，存储数字和运算符，存储最终的后缀表达式2. 对于新字符进⾏判断只要新字符不等于‘\0’，⼀直进⾏下⾯的循环：1. 如果S1的⼤⼩为空, 字符⼊S12. 如果是( ⼊栈3. 如果是)，将S1知道(之前的运算符出栈，添加到S2中4. 如果S1的⼤⼩不为空，并且S1栈顶的运算符优先级⼤于当前的新字符或者两个字符是相等的那么当前的S1栈顶就可以出栈，添加到S2中新字符⼊栈S15. 如果新字符的范围是‘0’ - ’9‘之间，那么新字符添加进S2中6. 否则，添加到S1中3. 跳出循环后，如果S1的size不为空，把S1的运算符⼀⼀弹出，添加到S2中，最终S2就是排列好的后缀表达式4. 然后就可以进⾏运算代码，使⽤c++int weight(const char code) {if((code == '+')|| (code == '-')) {return 1;}else if((code == '*')|| (code == '/')) {return 2;}}bool priority(const char left, const char right) {if(left == '(') {return false;}else if(weight(left) < weight(right)) {return false;}else {return true;}}bool caculation(const char* input, LinkStack<char>& S2) {if(input == NULL) {return false;}bool ret = true;LinkStack<char> S1;int i = 0;int out_index = 0;while(ret && (input[i] != '\0')) {if(input[i] == '(') {S1.push(input[i]);}else if((S1.size() > 0) && (input[i] == ')')) {char code = S1.get();while(code != '(') {S2.push(code);S1.pop();code = S1.get();}if(code == '(') {S1.pop();}}else if((S1.size() > 0) && priority(S1.get(), input[i])) {std::cout << "13" << std::endl;char code = S1.get();S2.push(code);S1.pop();S1.push(input[i]);}else if( (input[i] >= '0') && (input[i] <= '9')) {S2.push(input[i]);}else {S1.push(input[i]);}i++;}while(S1.size() > 0) {char code = S1.get();S2.push(code);S1.pop();}return ret;}4. 核⼼函数就是上⾯的两个，输⼊参数1是中缀表达式，输⼊参数2是栈，最终栈中存储排序好的后缀表达式5. 拿⼀个例⼦来演⽰⼀下：6.说明后缀表达式，这种⽅式后计算优点也很⼤，直接从上到下，数字就⼊栈，符号就把当前栈中的连续两个弹出，然后和当前符号进⾏运算，然后再⼊数字栈。

后缀表达式转换原则

后缀表达式转换原则后缀表达式，也称为逆波兰表达式，是数学计算中常用的一种表达式形式。

与中缀表达式相比，后缀表达式更加简洁明了，方便计算机进行计算。

本文将介绍后缀表达式转换的原则及其应用。

一、后缀表达式的定义后缀表达式是一种不含括号的表达式形式，运算符位于操作数之后。

例如，中缀表达式“5 + 3”可以转换为后缀表达式“5 3 +”。

后缀表达式的优势在于不需要考虑运算符的优先级和括号的使用，计算机可以直接按照从左到右的顺序进行计算。

二、后缀表达式转换的原则1. 从左到右依次扫描中缀表达式的每个元素。

2. 如果扫描到的是操作数，直接将其输出。

3. 如果扫描到的是运算符，将其与前面的操作数一起输出。

4. 如果扫描到的是左括号，将其压入栈中。

5. 如果扫描到的是右括号，将栈中的元素依次弹出并输出，直到遇到左括号为止。

6. 重复步骤2至5，直到扫描完所有元素。

7. 将栈中剩余的元素依次弹出并输出。

三、后缀表达式转换的示例以中缀表达式“2 + 3 * 4”为例，按照上述原则进行转换：1. 扫描到2，直接输出。

2. 扫描到+，将其与前面的2一起输出。

3. 扫描到3，直接输出。

4. 扫描到*，将其与前面的3一起输出。

5. 扫描到4，直接输出。

6. 扫描完所有元素，将栈中剩余的元素依次弹出并输出。

经过转换后，得到后缀表达式“2 3 4 * +”。

四、后缀表达式的应用后缀表达式在计算机科学和工程领域有广泛的应用。

其中，最常见的应用是计算器的实现。

计算器可以通过将用户输入的中缀表达式转换为后缀表达式，然后利用栈来计算表达式的值。

以后缀表达式“2 3 4 * +”为例，计算过程如下：1. 从左到右依次扫描后缀表达式的每个元素。

2. 如果扫描到的是操作数，将其压入栈中。

3. 如果扫描到的是运算符，弹出栈顶的两个操作数进行计算，并将计算结果压入栈中。

4. 继续重复步骤2和3，直到扫描完所有元素。

5. 最终栈中的唯一元素即为表达式的值。

前缀后缀算数运算编程

一、设计思想1、中缀转化为后缀算法过程中要使用一个栈和两个数组，（栈用来存放运算符，一个数组用来存放中缀表达式，两一个则是存放后缀表达式）表达式的转换过程如下：（1）、将表达式开始符“#“压入运算符栈，作为栈底元素。

（2）、从左到右依次扫描中缀表达式的每一个字符。

（3）、如果遇到的是开括号“（”，则将它们压入一个操作符栈（不需要与栈顶操作符相比较），它表明一个新的计算层次的开始，在遇到和它匹配的闭括号“）”时，将栈中的元素弹出来并放入后缀表达式中，直到栈顶元素为“(”时，将栈顶元素“（”弹出（不需要加入后缀表达式），表明这一层括号内的操作处理完毕（4）、即将进栈的操作符要与栈顶的操作符进行优先级比较，若当所遇到的操作符的优先级大于栈顶元素时，进栈，否则是将栈顶元素一次弹栈放入后缀数组，直到比较操作符小于或等于栈顶元素时为止。

重复以上操作，最后将栈内所有操作符放进后缀数组内。

（5）、重复上述步骤直到缀表达式的结束符标记“#“，弹出栈中所有元素并放入后缀表达，转换结束。

中缀表达式为：17-3*4+（8/2）# 后缀表达式为：17 3 4 * - 8 2/+2、中缀转化为前缀算法过程中要使用三个数组，（一个栈数组，一个存放中缀表达式，一个存放前缀表达式）表达式的转换过程如下：（1）将表达式开始符“#“压入运算符栈数组，作为栈底元素。

（2）、从右到左依次扫描中缀表达式的每一个字符。

（3）、如果遇到的是开括号“）”，则将它们放进栈数组内（不需要与栈顶操作符相比较），它表明一个新的计算层次的开始，在遇到和它匹配的闭括号“（”时，将栈中的元素弹出来并放入前缀表达式中，直到栈顶元素为“）”时，将栈顶元素“）”弹出（不需要加入后缀表达式），表明这一层括号内的操作处理完毕（4）、如果遇到的是操作符，则将该操作符和操作符栈顶元素比较：当所遇到的操作符的优先级小于栈顶元素的优先级时，则取出栈顶元素放入后缀表达式，并弹出该栈顶元素，反复执行直到操作符的优先级大于或等于栈顶元素的优先级的时则将它压入栈中。