⑴ 表达式a*（b+C）-d的后缀表达式什么 什么叫中缀和后缀
根据所给表达式（其实正常的都是中缀表达式）可以构造二叉树
—
／ ＼
* d
／ ＼
a +
／ ＼
b c
中缀表达式就是中序遍历a*(b+c)-d
后缀表达式就是后续遍历abc+*d-
前缀表达式就是前序遍历-*a+bcd
⑵ 关于数据结构（Pascal）中缀表达式转后缀表达式
var
ni,tuo:array[0..10000] of char; {ni是描述入栈，tuo是描述出栈}
nd,td,i,j,k,l:longint; {nd是ni的栈顶，td是tuo的栈顶}
tp:char; {tp读入字符}
fh:array[0..3,1..2] of char; {fh用于判断符号的优先级}
function fhpd(ch:char):integer; {判断符号优先级}
var i,j:integer;
begin
for i:=0 to 2 do
for j:=1 to 2 do
if ch=fh[i,j] then exit(i);
exit(-1);
end;
begin
fillchar(ni,sizeof(ni),' ');
fillchar(tuo,sizeof(tuo),' ');
fh[1,1]:='+';fh[1,2]:='-';fh[2,1]:='*';fh[2,2]:='/';fh[0,1]:='('; {全部初始化}
read(tp);
while tp<>'.' do {当读入“.”说明中缀表达式读入完毕}
begin
if (tp=')') then {如果是‘）’就将最近的一个‘(’之间的符号，全部倒入tuo中，并将‘（’和‘）’去掉}
begin
while ni[nd]<>'(' do
begin
inc(td);
tuo[td]:=ni[nd];
ni[nd]:=' ';
if not(nd=1) then dec(nd); {防止栈底溢出}
end;
ni[nd]:=' '; {去掉‘（’}
dec(nd);
end
else begin
if (tp in ['0'..'9']) then begin inc(td);tuo[td]:=tp;end else {如果是数字，则之间置入tuo中}
begin
if (ni[1]=' ')and(fhpd(tp)<>-1) then begin nd:=1;ni[nd]:=tp; end else {如果栈为空}
begin
if (ni[1]<>' ')and(fhpd(tp)<>-1) then {如果栈不为空，且tp为合法符号}
begin
if ((fhpd(tp)>fhpd(ni[nd]))or(tp='(')) then {如果tp大于ni的栈顶符号，或者tp是‘（’}
begin
inc(nd);
ni[nd]:=tp; {直接置入ni栈中}
end
else
begin
while (nd<>0)and(not((fhpd(tp)>fhpd(ni[nd])))) do
{如果tp小于ni的栈顶符号，就将大于tp的符号倒入tuo中，直到ni的栈顶小于等于tp，就将tp加入ni}
begin
inc(td);
tuo[td]:=ni[nd];
dec(nd);
end;
inc(nd);
ni[nd]:=tp;
end;
end;
end;
end;
end;
read(tp);
end;
while nd<>0 do {最后将所用ni栈中的符号全部按照正规操作模式，倒入tuo中}
begin
inc(td);
tuo[td]:=ni[nd];
dec(nd);
end;
for i:=1 to td do write(tuo[i],' '); writeln; {从tuo的栈底开始输出字符}
readln;readln;
end.
⑶ 什么是前缀表达式，中缀表达式，后缀表达式
前缀就是运算符在两个操作数的前面，其他已此类推。
比如，+
A
B
属前缀
咱们平常使用的属中缀比如
A
+
B
后缀自然就是
A
B
+
⑷ 数据结构 前缀表达式 中缀表达式 后缀表达式各是什么啊 怎么相互转化呢 求详细解释 谢谢！
例如要表达3+5：
+ 3 5
3+5
3 5 +
分别是前缀、中缀、后缀表达式。前缀、中缀、后缀是指运算符号所放位置的差异！
⑸ 数据结构中缀式中缀表达式改后缀表达式并求值
搞两个栈，一个存数字，一个存符号，处理一下优先级就可以了。
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<string>
int a[10][10]={{3,2,2,3,3},{3,3,2,3,3},{2,2,2,1,0},{3,3,0,3,3},{2,2,2,0,1}};
char t[100];
using namespace std;
struct node
{
int h;
char c;
node *p;
};
int pd(char ch)
{
if((ch=='+')||(ch=='-'))return 0;
if((ch=='*')||(ch=='/'))return 1;
if(ch=='(')return 2;
if(ch==')')return 3;
if(ch=='@')return 4;
}
int main()
{
node *r,*q;
int i,l,k=0,v,w,o;
string s;
cin>>s;
l=s.length();
s[l]='@';
l++;
q=new node;
q->c='@';
for(i=0;i<=l-1;i++){
if((s[i]>='0')&&(s[i]<='9')){
t[k]=s[i];
k++;
if((s[i+1]<'0')||(s[i+1]>'9')){
t[k]=' ';
k++;
}
continue;
}
w=pd(s[i]);
v=pd(q->c);
switch (a[v][w]){
case 1:
q=q->p;
break;
case 2:
r=q;
q=new node;
q->c=s[i];
q->p=r;
break;
case 3:
r=q;
q=new node;
q->c=s[i];
q->p=r;
while(a[v][w]==3){
t[k]=q->p->c;
k++;
q->p=q->p->p;
v=pd(q->p->c);
w=pd(q->c);
}
if(a[v][w]==1)
q=q->p->p;
break;
}
}
q=new node;
for(i=0;i<=k-1;i++){
if(((t[i]>'9')||(t[i]<'0'))&&(t[i-1]>='0')&&(t[i-1]<='9')){
o=1;
v=i-1;
w=0;
while(t[v]>='0'){
w=w+o*(t[v]-'0');
o=o*10;
v--;
}
r=q;
q=new node;
q->h=w;
q->p=r;
}
switch(t[i]){
case '+':
q->p->h+=q->h;
q=q->p;
break;
case '-':
q->p->h-=q->h;
q=q->p;
break;
case '*':
q->p->h*=q->h;
q=q->p;
break;
case '/':
q->p->h/=q->h;
q=q->p;
break;
}
}
cout<<q->h;
return 0;
}
⑹ 写出对应的中缀算术表达式
(24+8)*3/4*(10-7)
⑺ 数据结构的一道题：中缀表达式A-（B+C/D）*E的后缀形式是什么为什么
后缀表达式是把运算符号放在操作数后面
ABCD/+E*-
计算方法是：
1.把表达式中的每个操作都加括号,（A-（（B+（C/D））*E））
2.把运算符号移到对应括号后面：
(A((B(CD)/)+)E)*)-
3.去掉括号：
ABCD/+E*-
⑻ 数据结构：表达式的前缀表达式和后缀表达式
A ^ B * C - D + E / (F / (G + H))
简单说下解题思路，仅供参考。
首先找到前两个操作数，在这里是AB，取离它最近的那个符号，是^，组合起来，作为一项，这样表达式变成 + - * (A ^ B) C D / E / F + G H
继续这样，前两个操作数是(A ^ B)和C，符号是*，合并作为一项，变成 + - (A ^ B * C) D / E / F + G H
继续，变成 + （A ^ B * C - D) / E / F + GH
这个时候，+的一个操作数是(A ^ B * C - D)，另一个操作数是第一个/后边的结果
然后我们看怎么解 / E / F + GH，还是这样，被除数是E，除数是 / F + GH
/ F + GH的被除数是F，除数是 + G H, 即为(G + H), 这项是F / (G + H)
回到上一步，/ E / F + G H是E / (F / (G + H))
再往上回一步，得到整个表达式。
抽象一点，大概是这样：对于一个表达式，找到第一个操作数，它肯定是它左边紧挨着的那个运算符的左值（比如这道题里的A是第一个操作数，是^的左值）。操作数右边如果是操作数，那么肯定是之前找到的操作符的右值，如果是操作符，重复这个过程
2. 先把中缀表达式转化为后缀。这个方法到处都能搜到。
后缀表达式 3 2 * 4 2 2 * + 6 3 * - ^ 5 -
这个求值过程应该是没有运算符栈的
⑼ 表达式求值 数据结构中缀表示转换为后缀表达式
我们在数学中常见的计算式，例如2+（3*4）叫做中缀表达式。表达式中涉及到了多个运算符，而运算符之间是有优先级的。计算机在计算并且处理这种表达式时，需要将中缀表达式转换成后缀表达式，然后再进行计算。 中缀表达式转后缀表达式遵循以下原则： 1.遇到操作数，直接输出； 2.栈为空时，遇到运算符，入栈； 3.遇到左括号，将其入栈；
4.遇到右括号，执行出栈操作，并将出栈的元素输出，直到弹出栈的是左括号，左括号不输出；
5.遇到其他运算符'+''-''*''/'时，弹出所有优先级大于或等于该运算符的栈顶元素，然后将该运算符入栈；
6.最终将栈中的元素依次出栈，输出。
经过上面的步骤，得到的输出既是转换得到的后缀表达式。
⑽ 简单的解释下后缀表达式是什么
举个例子吧:
对于算式1*2+(2-1)来说,这是一个中缀表达式(就是平时计算用的式子)
转化为后缀表达式的过程为:
先说统一的过程:
1.从左到右依次读取算式的一个字符
2.如果读到括号,则跳过,到下一个字符
3.如果读到的字符是数字,则直接输出到一个结果字符串的末尾(这个结果字符串到最后就是要的后缀表达式)
4.如果读到的是运算符,则要将此运算符入栈
(1) 若栈空,则直接入栈;
(2) 若栈不空则要判断栈顶运算符的优先级:
<1>若栈顶运算符的优先级低于要入栈的运算符,直接入栈
<2>若栈顶运算符的优先级高于要入栈的运算符,要将栈顶位置的高优先级的运算符出栈,出栈的运算符输 出到结果字符 串的末尾.
,直到栈顶运算符优先级低于要入栈的运算符为止.(实际上就是要保证栈中的运算符优先级从栈顶到 栈底是依次从高到低的)
5.依次按上述方式读取,直到将次中缀表达式读完.最后的结果就保存在这个结果字符串.
6.最后将栈中还有的运算符出栈,加入到结果字符串中去.就得到了后缀表达式
举例说明1*2+(2-1)
设结果字符串String result="";//开始为空
设存储运算符的栈为stack=空//开始为空,从左到右为栈底和栈顶
第一个字符为1,直接加入到结果字符串result=="1";
第二个字符为*,栈为空,直接入栈.stack=*
第三个字符为2,加入到结果字符串result=="12";
第四个字符为+.栈不空,入栈.栈顶运算符*优先级高于要入栈运算符+,故*先出栈,加入到结果字符串
result=="12*";然后入栈stack=+
第五个字符为(直接跳过
第六个字符为2,加入结果字符串result=="12*2"
第七个字符为-.栈不空,入栈,栈顶运算符+优先级高于要入栈运算符-,故+先出栈,加入到结果字符串
result=="12*2+";然后入栈stack=-
第七个字符为1,加入结果字符串result=="12*2+1"
第八个字符为).跳过,
到此为止中缀表达式读取完毕
将栈里的运算符依次出栈加入结果字符串
result=="12*2+1-"得到了最终的后缀表达式
第二个问题:后缀表达式的计算
1.将后缀表达式从左到右依次读取
2.如果读到数字,直接入栈
3.如果读到运算符,则将栈顶的两个数字出栈,和此运算符做运算
注意: 先出栈的数为减数,后出栈的为被减数(除法类似)
将此计算的结果再压入栈中
4.重复上述步骤,最终的运算结果就存在栈里
举例说明:上面得到的后缀表达式:12*2+1-
设栈为stack
第一个字符1,入栈stack=1
第二个字符2,入栈stack=12
第三个字符*.栈元素出栈做运算1*2得到2,再入栈stack=2
的四个字符2,入栈stack=22
第五个字符+,栈元素出栈做运算2+2得到4,再入栈stack=4
第六个字符1,入栈stack=41
第七个字符-,栈元素出栈做运算4-1得到3,再入栈stack=3
到此为止,后缀表达式读取完毕,栈中就存储最终结果3
你可以算算和原始的中缀表达式1*2+(2-1)结果相同吧~