前缀表达式算法

① 增1减1运算符，前缀运算和后缀运算请大大们详细举例讲解，为什么有变量的值和表达式的值

额
举个例子

下面的几个表达式都在 int i=0 的基础上运算
1：int j = i++；这里i=0、表前槐做达式的值j=1；
2：int j = ++i；这里i=1、表达式的值j=1；
3：int j = i--；这里i=0、表达式的明轿值j=-1；
4：int j = --i；这里i=-1、表达式的值j=-1；

这4个例子你应该能明白一点吧
其实就是两个重点
1：前缀会在表达式运算前获得新值慧衡、后缀在表达式运算后获得新值
2：表达式和变量的值是两个概念，要注意分离

② 中缀表达式转前缀表达式

全是自己写的~~给分~~
#include<iostream>
#include<string>
using namespace std;
#define maxSize 100
class Stack{
public:
Stack() {top = -1 ; };
bool Push(char a)
{
if(!IsFull())
c[++top] = a;
else
return false;
return true;
}
bool pop(char &a)
{
if(!IsEmpty())
a = c[top--];
else
return false;
return true;
}
bool getTop(char &a)
{
if(!IsEmpty())
a = c[top];
else
return false;
return true;
}
bool IsEmpty()
{
return top == -1 ? true:false ;
}
bool IsFull()
{
return top == (maxSize-1) ? true:false ;
}
private:
char c[maxSize];
int top;
};
int isp(char a)
{
if(a == '#')
return 0;
if(a == '(')
return 6;
if(a == '*' || a == '/')
return 4;
if(a == '+' || a == '-')
return 2;
if(a == ')')
return 1;
return false;
}
int icp(char a)
{
if(a == '#')
return 0;
if(a == '(')
return 1;
if(a == '*'携竖 || a == '/')
return 5;
if(a == '+' || a == '-')
return 3;
if(a == ')')
return 6;
return false;
}
void main()
{
cout<<"本程序将为您把中缀表达式转换成前缀表达式。"<<endl<<endl;
string s;
char c[100];
char a,b;
cout<<"辩颂大请樱铅输入一个多项式的运算。"<<endl;
cin>>s;
s = "#"+s;
int m,n;
for(m=n=0 ; s[n]!='\0' ; n++);
n--;
Stack z;
z.Push('#');
while(n >= 0 && !z.IsEmpty())
if(isdigit(s[n]))
c[m++] = s[n--];
else
{
z.getTop(a);
if(isp(a) < icp(s[n]))
z.Push(s[n--]);
else if(isp(a) > icp(s[n]))
z.pop(b) , c[m++] = b;
else
{
z.pop(b);
if(b == ')')
n--;
}
}
m--;
cout<<endl<<"将以上多项式运算转换为前缀表达式为："<<endl;
for( ; m >=0 ; m--)
cout<<" "<<c[m];
}

③ 中缀表达式如何转换为前后缀表达式

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

④ 从键盘输入一个前缀表达式，运算符可以包括+-*/（），操作数任意，中间不可以有空格，编写c语言算法

#include
#include
#include
int main(void)
{
float a,b,f;
int ctl=0,p;
char Cflag='Y';
char c;
char sa[10],sb,sc[10];
while((Cflag == 'Y') || (Cflag == 'y') )
{
for(p=0;p sb='\0';
for(p=0;p p=0;
ctl=1;
printf("加、蠢歼模改历减、乘、除四则运算算式:\n");
scanf("%c", &c);
while(c!='\n')
{
if (c>='0' && c {
if ( ctl==1 ) sa[p]=c;
if ( ctl==2 ) sc[p]=c;
p++;

}else if ( c=='+'||c=='-'||c=='*'||c=='/')
{
ctl=2;
sa[p]='\0';
sb=c;
p=0;
}

scanf("%c", &c);
}
sc[p]='\0';
//printf("[%s%c%s]",sa,sb,sc);
a=atof(sa);
b=atof(sc);
switch(sb)
{
case '+':
f=a+b;
break;
case '-':
f=a-b;
break;
case '*':
f=a*b;
break;
case '/':
f=a/b;
break;
defalt:
;
}
printf("[%.2f%c%.2f]=%.2f"带缓,a,sb,b,f);

printf("\n是否继续计算(Y/N)?");
scanf("%c", &Cflag);
getchar();

}
}

⑤ 如何把算术表达式转化为后缀表达式有个例子，a

一.表达式的三种形式：
中缀表达式：运算符放在两个运算对象中间，如：(2+1)*3
后缀表达式：不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：2 1 + 3 *
前缀表达式：同后缀表达式一样，不包含括号，运算符放在两个运算兆袜中对象的前面，如：* + 2 1 3

二.表达式的转换：
将中缀表达式转换为后缀表达式好基的算法思想：
·数字时，加入后缀表达式；
·运算符：
a. 若为最低级的运算符，入栈；
b. 若为 '('，入栈；
c. 若为 ')'，则把栈中的的运算符加入后缀表达式中，直到 '('，从栈中删除'(' ;
d. 若为不是最低级的运算符，则将从栈顶到第一个优先级不大于（小于，低于或等于）它的运算符（或 '(',但优先满足前一个条件）之间的运算符加入后缀表达式中，该运算符再入栈；

>>这句话不好理解，可以说成这样，从栈顶开始，依次弹出比当前处理的运算符优先级高的运算符，直到一个比它优先级低的或者遇到了一个左括号就停止。

·当扫描的中缀表达式结束时，栈中的的所有运算符出栈；

运用后缀表达式进行计算的具体做法：
·建立一个栈S
·从左到右读后缀表达式，读到数字就将它转换为数族山值压入栈S中，读到运算符则从栈中依次弹出两个数分别到Y和X，然后以“X 运算符 Y”的形式计算机出结果，再压加栈S中
·如果后缀表达式未读完，就重复上面过程，最后输出栈顶的数值则为结束

三.表达式之间的转换
这里我给出一个中缀表达式：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 / * +

⑥ C语言代码补全：前缀表达式求值

#include<stdio.h>
#include<stdlib.h>
#define MAXNUM 100
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;

typedef int selemtype1; //定义运算数栈的结点

typedef struct //定义运算数栈的类型
{selemtype1 *base;
selemtype1 *top;
}sqstack1;

void InitStack1(sqstack1 &s) //新建一个空运算数栈
{s.base=(selemtype1 *)malloc(MAXNUM*sizeof(selemtype1));
s.top=s.base;
if(!s.base) printf("出错：申请空间失败！\n");
}

void Push1(sqstack1 &s,selemtype1 &e) //运算数栈，入栈：插入元素e为新的栈顶元素
{ if(s.top-s.base>=MAXNUM)
printf("出错：表达式过长！1\n");
*s.top++ =e;
}

void GetTop1(sqstack1 s,selemtype1 &e) //运算数栈，用e返回栈顶元素 {e=*(s.top-1);
}

void Popopnd1(sqstack1 &s,selemtype1 &e) //运算数栈，退栈：删除栈顶物锋袭元素，并用e返回其值
{e=*--s.top;
}

int stackempy1(sqstack1 s) //运算数栈，若为空栈返回1，否则返回0 {if(s.top==s.base) return 1;
else return 0;
}

typedef char selemtype2; //定义运算符栈的结点类型

typedef struct //定义运算符栈类型
{selemtype2 *base;
selemtype2 *top;
}sqstack2;

void InitStack2(sqstack2 &s) //新建一个空运算符栈
{s.base=(selemtype2 *)malloc(MAXNUM*sizeof(selemtype2));
s.top=s.base;
if(!s.base) printf("出错：申请空间失败！\n");
}

void Push2(sqstack2 &s,selemtype2 &e) //运算符栈，入栈：插入元素e为新的栈顶元素
{ if(s.top-s.base>=MAXNUM)
printf("出错：表达式过长！2\n");
*s.top++ =e;
}

void GetTop2(sqstack2 s,selemtype2 &e) //运算符栈，用e返回栈顶元素 {e=*(s.top-1);
}

void Popopnd2(sqstack2 &s,selemtype2 &e) //运算符栈，退栈：删除栈顶元素，并用e返回其值
{e=*--s.top;
}

int stackempy2(sqstack2 s) //运算符栈，若为空栈返回1，否则返回0 {if(s.top==s.base) return 1;
else return 0;
}

⑦ 求前缀表达式的值现实中的作用

1、在计算机科学中，前缀表达式求值可以用于编译器的语法分析，以及计算机程序的解释和执行余拿李。
2、在数学中，前缀表达式求值可以用于解决复杂的数学表达式，如求敏塌解微积分、线性代数等问题。
3、在计算机网络中，前缀表达式求值可以用于路由算法，以竖迟及计算机网络中的路由表的构建。

⑧ 前缀中缀后缀表达式的转换，能帮一下吗

思路的话其实很简单，就是构建一棵二叉树，根行亏节点和中间节点为运算符，叶子结点为运算数字。如 a + b*c， 构建为二叉树的话，档岩神就如下图： +a * b c对于该二叉树，使用不同的遍历方式就可以得到不同的表达式了。遍历的代码很简单就不多说了。因此，你的问题主要可以分解为3个小问题：1。将后缀表达式转换为二叉树 该方法是最简单的。如a + b*c 的后缀表达式为 bc*a+.处理步骤如下： 1。建立一个栈S
2。从左到右读后缀表达式，读到数字就创建叶子节点，节点值为数字值。将节点压入栈S中，读到运算符则创建中间节点，并从栈中依次弹出两个节点分别为Y和X，作为中间节点的左右子节点，然后以“X 运算符 Y”的形式计算机出中间节点的值，再将此中间节点压加栈S中 3。就重复第二步直至后缀表达式结束，此时栈顶的节点就是二叉树的根节点了。2。将中缀表达式转换为二叉树 按照上一个回答者的方法将中缀表达式转为后缀表达式，然后调用后缀表达式生成二叉树的解法即可。3。将前缀表达式转换为二叉树 将前缀表达式直接取反即为后缀表达式。 如前缀表达式为+*bca，对应枣液的后缀表达式为acb*+。因此，我们只需要字符串取反，然后调用后缀表达式的方法生成二叉树即可。

⑨ 用栈将一个将中缀表达式转换为前缀表达式的算法

1）求输入串的逆序。

2）检查输入的下一元素。

3）假如是操作数，把它添加到输出串中。

4）假如是闭括号，将它压栈。

5）假如是运算符，则

i)假如栈空，此运算符入栈。

ii)假如栈顶是闭括号，此运算符入栈。

iii)假如它的优先级高于或等于栈顶运算符，此运算符入栈。

iv)否则，栈顶运算符出栈并添加到输出串中，重复步骤5。

6）假如是开括号，栈中运算符逐个出栈并输出，直到遇到闭括号。闭括号出栈并丢弃。

7）假如输入还未完毕，跳转到步骤2。

8）假如输入完毕，栈中剩余的所有操作符出栈并加到输出串中。

9）求输出串的逆序。*/

#include<iostream>

#include<string>

using namespace std;

char stack[50];//定义顺序栈，其中第一个元素表示栈为空；

int top=0;//栈顶指针，为0表示栈为空；

int level(char op)//判断运算符级别函数；其中* /的级别为2，+ -的级别为1；

{

int level;

switch(op)

{

case'+':

case'-':level=1; break;

case'*':

case'/':level=2; break;

default:level=0;break;

}

return level;

}

bool isOperator(char op)//判断输入串中的字符是不是操作符，如果是返回true

{

if(op=='+'||op=='-'||op=='*'||op=='/')

return true;

else

return false;

}

string convert(string s)//将一个中缀串转换为后缀串，

{

string output="";//输出串

for(int i=s.length()-1;i>=0;)//1）求输入串的逆序。

{

if(s[i]>=48&&s[i]<=57)

output=output+s[i];//3）假如是操作数，把它添加到输出串中。

if(s[i]==')')//4）假如是闭括号，将它压栈。

{

top++;

stack[top]=s[i];

}

while(isOperator(s[i]))//如果是运算符，执行算法(5)对应操作；

{

if(top==0||stack[top]==')'||level(s[i])>=level(stack[top]))

{

top++;

stack[top]=s[i];

break;

}

else

{

output=output+stack[top];

top--;

}

}

if(s[i]=='(')//6）假如是开括号，栈中运算符逐个出栈并输出，直到遇到闭括号。闭括号出栈并丢弃。

{

while(stack[top]!=')')

{

output=output+stack[top];

top--;

}

top--;

}

i--;//7）假如输入还未完毕，跳转到步骤2。

}

while(top!=0)//8）假如输入完毕，栈中剩余的所有操作符出栈并加到输出串中。

{

output=output+stack[top];

top--;

}

return output;

}

int main()

{

string input,output;

cout<<"请输入串:";

cin>>input;

output=convert(input);

cout<<"后缀串为:";

for(int i=output.length()-1;i>=0;i--)//9）求输出串的逆序。

cout<<output[i];

cout<<endl;

return 0;

}

⑩ 请教波兰表达式前缀表达式的算法

对于一个前缀表达式的求值而言，首先要从右至左扫描表达式，从右边第一个字符开始判断，如果当前字符是数字则一直到数字串的末尾再记录下来，如果是运算符，则将右边离得最近的两个“数字串”作相应的运算，以此作为一个新的“数字串”并记录下来。一直扫描到表达式的最左端时，最后运算的值也就是表达式的值。例誉拆型如，前御睁缀表达式“- 1 + 2 3“的求值，扫描到3时，记录下这个数字串，扫描到2时，记录下这个数字串，当扫描到+时，将+右移做相邻两数字串的运算符，记为2+3，结果为5，记录下这个新数字串，并继续向左扫描，扫描到1时，记录下这个数字串，扫描到-时，将-右庆猜移做相邻两数字串的运算符，记为1-5，结果为-4，所以表达式的值为-4。