前缀表达式是什么意思

1. 前缀表达式是什么意思

前缀表达式
是一种没有括号的
算术表达式
，与中缀表达式不同的是，其将运算符写在前面，
操作数
写在后面。为纪念其发明者波兰数学家Jan
Lukasiewicz，前缀表达式也称为“
波兰式
”。例如，-
1
+
2
3，它等价于1-(2+3)。

2. 前缀表达式的释义

前缀表达式就是前序表达式。例如，- 1 + 2 3，它等价于1-(2+3)。

3. 前缀表达式的介绍

前缀表达式就是不含括号的算术表达式，而且它是将运算符写在前面，操作数写在后面的表达式，为纪念其发明者波兰数学家Jan Lukasiewicz也称为“波兰式”。例如，- 1 + 2 3，它等价于1-(2+3)。

4. 前缀表达式

对前缀表达式求值,要从右至左扫描表达式,首先从右边第一个字符开始判断,若当前字符是数字则一直到数字串的末尾再记录下来,若为运算符,则将右边离得最近的两个“数字串”作相应运算,然后以此作为一个新的“数字串”并记录下来;扫描到表达式最左端时扫描结束,最后运算的值即为表达式的值。 
 例如:对前缀表达式“- 15 *  2 4 ”求值,扫描到4时,记录下这个数字串,扫描到2时,记录下这个数字串,当扫描到*时,将已经记下的两个数字相乘，得到8（作为新的第一个数），再继续扫描，得到15，（第二个数），扫描到“-”，将15-8，得到7，因为扫描已经结束，所以，7就是整个前缀表达式的值。

5. 后缀表达式

后缀表达式
目录
概述
计算
转换
代码
转成
求值
编辑本段概述
不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2 + 1) * 3 ， 即2 1 + 3 *
编辑本段计算
运用后缀表达式进行计算的具体做法：
建立一个栈S 。从左到右读后缀表达式，如果读到操作数就将它压入栈S中，如果读到n元运算符(即需要参数个数为n的运算符)则取出由栈顶向下的n项按操作符运算，再将运算的结果代替原栈顶的n项，压入栈S中 。如果后缀表达式未读完，则重复上面过程，最后输出栈顶的数值则为结束。
编辑本段转换
计算机实现转换：
将中缀表达式转换为后缀表达式的算法思想：
·开始扫描；
·数字时，加入后缀表达式；
·运算符：
a. 若为 '('，入栈；
b. 若为 ')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ；
c. 若为 除括号外的其他运算符， 当其优先级高于栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。
·当扫描的中缀表达式结束时，栈中的的所有运算符出栈；
人工实现转换
这里我给出一个中缀表达式：a+b*c-(d+e)
第一步：按照运算符的优先级对所有的运算单位加括号：式子变成了：((a+(b*c))-(d+e))
第二步：转换前缀与后缀表达式
前缀：把运算符号移动到对应的括号前面
则变成了：-( +(a *(bc)) +(de))
把括号去掉：-+a*bc+de 前缀式子出现
后缀：把运算符号移动到对应的括号后面
则变成了：((a(bc)* )+ (de)+ )-
把括号去掉：abc*+de+- 后缀式子出现
发现没有，前缀式，后缀式是不需要用括号来进行优先级的确定的。如表达式：3+(2-5)*6/3
后缀表达式 栈
3_________________+
3 ________________+(
3 2 _______________+(-
3 2 5 -_____________ +
3 2 5 - _____________+*
3 2 5 - 6 * ___________+/
3 2 5 - 6 *3 __________+/
3 2 5 - 6 *3 /+________
("_____"用于隔开后缀表达式与栈)
另外一个人认为正确的转换方法:
遍历中缀表达式的每个节点，如果：
1、 该节点为操作数：
直接拷贝进入后缀表达式
2、 该节点是运算符，分以下几种情况：
A、 为“（”运算符：
压入临时堆栈中
B、 为“）”运算符：
不断地弹出临时堆栈顶部运算符直到顶部的运算符是“（”为止。并把弹出的运算符都添加到后缀表达式中
C、 为其他运算符，有以下步骤进行：
比较该运算符与临时栈栈顶指针的运算符的优先级，如果临时栈栈顶指针的优先级高于该运算符的优先级，弹出并添加到后缀表达式中，反复执行前面的比较工作，直到遇到一个栈顶指针的优先级低于该运算符的优先级，停止弹出添加并把该运算符压入栈中。
此时的比较过程如果出现栈顶的指针为‘（’，则停止循环并把该运算符压入栈中，注意：‘（’不要弹出来。
遍历完中缀表达式之后，检查临时栈，如果还有运算符，则全部弹出，并添加到后缀表达式中。
编辑本段代码
表达式之间的转换 c++代码
#include 
#include 
#include 
#include 
using namespace std;
bool isOper(char c)
//判断是否为操作符
{
if ((c== '+ ')||(c== '- ')||(c== '* ')||(c== '/ ')||(c== '( ')||(c== ') '))
return true;
return false;
}
bool isHigh(char top_op,char InfixExp_op)
//判断操作符的优先级
//top_op为栈顶操作符
//InfixExp_op为当前读入操作符
//如果栈顶操作符优先级高，则弹出栈顶操作符
//如果栈顶操作符优先级低，则压入当前读入操作符
{
if ((top_op== '+ ')&&(InfixExp_op== '+ ')) return true;
if ((top_op== '+ ')&&(InfixExp_op== '- ')) return true;
if ((top_op== '- ')&&(InfixExp_op== '+ ')) return true;
if ((top_op== '- ')&&(InfixExp_op== '- ')) return true;
if ((top_op== '* ')&&(InfixExp_op== '+ ')) return true;
if ((top_op== '* ')&&(InfixExp_op== '- ')) return true;
if ((top_op== '* ')&&(InfixExp_op== '* ')) return true;
if ((top_op== '* ')&&(InfixExp_op== '/ ')) return true;
if ((top_op== '/ ')&&(InfixExp_op== '+ ')) return true;
if ((top_op== '/ ')&&(InfixExp_op== '- ')) return true;
if ((top_op== '/ ')&&(InfixExp_op== '* ')) return true;
if ((top_op== '/ ')&&(InfixExp_op== '/ ')) return true;
if (InfixExp_op== ') ') return true;
return false;
}
void input(vector  *InfixExp)
{
char c;
cin> > c;
while(c!= '$ ')
{
InfixExp->push_back(c);
cin> > c;
}
}
void output(vector  *postfixExp)
{
vector  ::iterator postfixExp_it;//后缀表达式迭代器
for(postfixExp_it=postfixExp-> begin();postfixExp_it!=postfixExp-> end();postfixExp_it++)
cout < <*postfixExp_it < < " ";
cout < <endl;
}
void output2(vector  *postfixExp)
//不输出括号
//如果表达式中括号不配对
//则可能有多余的括号未弹出
{
vector  ::iterator postfixExp_it;//后缀表达式迭代器
for(postfixExp_it=postfixExp-> begin();postfixExp_it!=postfixExp-> end();postfixExp_it++)
{
if ((*postfixExp_it!= '( ')&&(*postfixExp_it!= ') '))
cout < <*postfixExp_it < < " ";
}
cout < <endl;
}
void main()
{
stack  mystack;
vector  InfixExp;//中缀表达式
vector  ::iterator InfixExp_it;//中缀表达式迭代器
vector  postfixExp;//后缀表达式
do
{
cout < < "Please input a formula, ended by $: " < <endl;
input(&InfixExp);
//输入表达式
output(&InfixExp);
for(InfixExp_it=InfixExp.begin();InfixExp_it!=InfixExp.end();InfixExp_it++)
{
if (!isOper(*InfixExp_it))
//操作数，直接输出
postfixExp.push_back(*InfixExp_it);
else
//操作符
{
if (mystack.empty())
//栈为空，压入操作符
mystack.push(*InfixExp_it);
else if(isHigh(mystack.top(),*InfixExp_it))
//栈顶操作符优先,比如栈顶为*,当前操作符为+，则弹出*
{
if (*InfixExp_it!= ') ')
//非闭括号
//弹出栈中操作符直到栈顶操作数优先级低于当前读入操作数
//压入当前读入操作符
{
do
{
postfixExp.push_back(mystack.top());
mystack.pop();
}while((!mystack.empty())&&(isHigh(mystack.top(),*InfixExp_it)));
mystack.push(*InfixExp_it);
}
else
//闭括号
{
while((!mystack.empty())&&(mystack.top()!= '( '))
//弹出直到开括号
{
postfixExp.push_back(mystack.top());
mystack.pop();
}
if ((!mystack.empty())&&(mystack.top()== '( '))
mystack.pop();
//弹出开括号
}
}
else if(!isHigh(mystack.top(),*InfixExp_it))
//中缀表达式中操作符优先
//比如栈顶为+,而当前读入*
{
mystack.push(*InfixExp_it);
//压入当前读入操作符
}
}
}
while(!mystack.empty())
//把栈中剩余的操作符依次弹出
{
postfixExp.push_back(mystack.top());
mystack.pop();
}
output2(&postfixExp);
while(!mystack.empty())
mystack.pop();
InfixExp.clear();
postfixExp.clear();
//清空栈、中缀表达式和后缀表达式
}while(true);
}
编辑本段转成
中缀表达式转成后缀表达式 pascal
program p2_29;
const
max=100;
op_set:set of char=['+','-','*','/'];
letter:set of char=['0'..'9'];
var
expression,result:string;
procedure sean(expression:string);
var
i,top1,top2:integer;
ovs:array [1..max] of string[max];
ops:array [1..max] of char;
f:array ['#'..'/','#'..'/'] of shortint;
begin
f['+','+']:=1; f['+','-']:=1; f['+','*']:=-1;
f['+','/']:=-1; f['+','(']:=-1; f['+',')']:=1;
f['+','#']:=1; f['-','+']:=1; f['-','-']:=1;
f['-','*']:=-1; f['-','/']:=-1; f['-','(']:=-1;
f['-','}']:=1; f['-','#']:=1; f['*','+']:=1;
f['*','-']:=1; f['*','*']:=1; f['*','/']:=1;
f['*','(']:=-1; f['*',')']:=1; f['*','#']:=1;
f['/','+']:=1; f['/','-']:=1; f['/','*']:=1;
f['/','/']:=1; f['/','(']:=-1; f['/',')']:=1;
f['/','#']:=1; f['(','+']:=-1; f['(','-']:=-1;
f['(','*']:=-1; f['(','/']:=-1; f['(','(']:=-1;
f['(',')']:=0; f['(','#']:=2; f[')','+']:=2;
f[')','-']:=2; f[')','*']:=2; f[')','/']:=2;
f[')','(']:=2; f[')',')']:=2; f[')','#']:=2;
f['#','+']:=-1; f['#','-']:=-1; f['#','*']:=-1;
f['#','/']:=-1; f['#','(']:=-1; f['#',')']:=2;
f['#','#']:=0;
{优先级设置}
expression:=expression+'#';{末尾加标志}
ops[1]:='#';
top1:=0;
top2:=1;
for i:=1 to length(expression) do {逐个扫描}
begin
if expression[i] in letter then {是数字就进栈}
begin
inc(top1);
ovs[top1]:=expression[i];
end
else begin {运算符}
while f[ops[top2],expression[i]]=1 do {栈顶运算符优先级高于当前运算符}
begin {取栈顶上面的两个元素运算后，再压栈}
ovs[top1-1]:=ovs[top1-1]+ovs[top1]+ops[top2];
top1:=top1-1;
dec(top2);
end;
if f[ops[top2],expression[i]]=0 then
top2:=top2-1 {优先级相同，则抵消}
else {栈顶运算符优先级低于当前运算符，则压栈}
begin
top2:=top2+1;
ops[top2]:=expression[i];
end;
end;
end;
result:=ovs[1];{返回结果}
end;
begin
readln(expression);
sean(expression);
writeln(result);
readln;
end.
编辑本段求值
后缀表达式的求值 pascal
注：输入时符号和数字要空一格
program p2_30a;
const
maxn=20;
var
stack:array [1..maxn] of integer;
s:string;
function comp(s:string):integer;
var
ch:char;
i,top,x,y,z:integer;
begin
top:=0;
i:=1;
ch:=s[i];
while i<=length(s) do {逐个位数判断}
begin
case ch of
'0'..'9':begin
x:=0;
while (ch' ') do
begin
x:=x*10+ord(ch)-ord('0'); {当前数位}
i:=i+1;
ch:=s[i];{下一位}
end;
inc(top);
stack[top]:=x;
end;
'+':begin
x:=stack[top]; dec(top);
y:=stack[top];{获得两个数}
z:=y+x; {计算}
stack[top]:=z; {存值}
end;
'-':begin
x:=stack[top]; dec(top);
y:=stack[top];{获得两个数}
z:=y-x; {计算}
stack[top]:=z; {存值}
end;
'*':begin
x:=stack[top]; dec(top);
y:=stack[top];{获得两个数}
z:=y*x; {计算}
stack[top]:=z; {存值}
end;
'/':begin
x:=stack[top]; dec(top);
y:=stack[top];{获得两个数}
z:=y div x; {计算}
stack[top]:=z; {存值}
end;
end;
inc(i);
ch:=s[i];
end;
exit(stack[top]);
end;
begin
readln(s);
writeln(comp(s));
readln;
end.

6. 中缀表达式如何转换为前后缀表达式？

1、中缀表达式变后缀的算法：遇到操作数，直接输出。

2、栈为空是，遇到运算符，直接入栈。

3、遇到左括号时，将其入栈。

4、遇到右括号时，执行出栈操作，并且开始将出栈的元素输出。直到弹出栈的元素是左括号为止。

5、遇到其他运算符的时候，弹出所有优先级大于等于该运算符栈顶元素，然后将该运算符入栈。最终将栈中的元素依次出栈。

7. 前缀表达式的相关例子

a+b ---> +,a,ba+(b-c) ---> +,a,-,b,ca+(b-c)*d ---> +,a,*,-,b,c,da+1+3 ---> +,+,a,1,3

8. 中缀表达式的中缀表达式

（或中缀记法）是一个通用的算术或逻辑公式表示方法， 操作符是以中缀形式处于操作数的中间（例：3 + 4），中缀表达式是人们常用的算术表示方法。与前缀表达式（例：+ 3 4）或后缀表达式（例：3 4 +）相比，中缀表达式不容易被计算机解析，但仍被许多程序语言使用，因为它符合人们的普遍用法。与前缀或后缀记法不同的是，中缀记法中括号是必需的。计算过程中必须用括号将操作符和对应的操作数括起来，用于指示运算的次序。例：（1）8+4-6*2用后缀表达式表示为：8 4+6 2*-（2）2*（3+5）-4+7/1用后缀表达式表示为：35+2*71/4-+