❶ 栈表示中缀表达式转后缀表达式，栈中存放的是什么内容
思路的话其实很简单，就是构建一棵二叉树，根节点和中间节点为运算符，叶子结点为运算数字。如 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;
}
❸ 利用堆栈求中缀表达式值
include <malloc.h>
#include <stdio.h>
#include <ctype.h>//判断是否为字符的函数的头文件
#define maxsize 100
typedef int elemtype;
typedef struct sqstack sqstack;//由于sqstack不是一个类型 而struct sqstack才是
char ch[7]=;//把符号转换成一个字符数组
int f1[7]=;//栈内元素优先级
int f2[7]=;//栈外的元素优先级
struct sqstack
{
elemtype stack[maxsize];
int top;
};
void Initstack(sqstack *s)
{
s->top=0;
}
void Push(sqstack *s,elemtype x)
{
if(s->top==maxsize-1)
printf("Overflow\n");
else
{
s->top++;
s->stack[s->top]=x;
}
}
void Pop(sqstack *s,elemtype *x)
{
if(s->top==0)
printf("underflow\n");
else
{
*x=s->stack[s->top];
s->top--;
}
}
elemtype Gettop(sqstack s)
{
if(s.top==0)
{
printf("underflow\n");
return 0;
}
else
return s.stack[s.top];
}
elemtype f(char c)
{
switch(c)
{
case '+':
return 0;
case '-':
return 1;
case '*':
return 2;
case '/':
return 3;
case '(':
return 4;
case ')':
return 5;
default:
return 6;
}
}
char precede(char c1,char c2)
{
int i1=f(c1);
int i2=f(c2);//把字符变成数字
if(f1[i1]>f2[i2])//通过原来设定找到优先级
return '>';
else if(f1[i1]<f2[i2])
return '<';
else
return '=';
}
int Operate(elemtype a,elemtype theta,elemtype b)
{
int sum;
switch(theta)
{
case 0:
sum=a+b;
break;
case 1:
sum=a-b;
break;
case 2:
sum=a*b;
break;
default:
sum=a/b;
}
return sum;
}
EvaluateExpression()
{
char c;
int i=0,sum=0;
int k=1,j=1;//设置了开关变量
elemtype x,theta,a,b;
sqstack OPTR,OPND;
Initstack(&OPTR);
Push(&OPTR,f('#'));//0压入栈
Initstack(&OPND);
c=getchar();
if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先对＋和-的情况忽略和左括号的情况
{
printf("错误1 \n");
k=0;
return 0;
}
if(c==ch[0])
c=getchar();//如果是＋，把它覆盖
if(c==ch[1])
{
j=0;
c=getchar();//也把－号覆盖
}
while(c!='#'||ch[Gettop(OPTR)]!='#')
{
if(isdigit(c))
{
sum=0;
while(isdigit(c))
{
if(!j)
{
sum=sum*10-(c-'0');//实现了数字串前面有负号（之前是：sum=-(sum*10)-(c-'0')结果是－12＋13＝21）
}
else
sum=sum*10+(c-'0');
c=getchar();
}
Push(&OPND,sum);//如果还是数字先不压栈，把数字串转化成十进制数字再压栈
j=1;
}
else
if(k)
{
switch(precede(ch[Gettop(OPTR)],c))
{
case'<': Push(&OPTR,f(c));//把它们整型化
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下个是‘（’的情况 也把以运算符归到这里来
{
printf("出错2\n");
k=0;
return 0;//加了开关变量和返回0的值使程序更以操作
}
break;
case'=': Pop(&OPTR,&x);
c=getchar();
if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情况也忽略了但此时并没有注意到右括号后面右运算符的情况
{
printf("出错2\n");
k=0;
return 0;
}
break;
case'>': Pop(&OPTR,&theta);
Pop(&OPND,&b);
Pop(&OPND,&a);//注意这里是谁先出栈
Push(&OPND,Operate(a,theta,b));
break;
}
}
}//在这里判断是否以运算符结束是不对的
return(Gettop(OPND));
}
main()
{
int result;
printf("输入你的算术表达式：\n");
result=EvaluateExpression();
printf("结果是 :%d\n",result);
return 0;
}
:
本计算器利用堆栈来实现。
1、定义后缀式计算器的堆栈结构
因为需要存储的单元不多，这里使用顺序栈，即用一维数组来模拟堆栈：
#define MAX 100
int stack[MAX];
int top=0;
因此程序中定义了长度为MAX的一维数组，这里MAX用宏定义为常数100，我们可以修改宏定义而重新定义堆栈的大小。
整型数据top为栈顶指示，由于程序开始时堆栈中并无任何数据元素，因此top被初始化为0。
2、存储后缀式计算器的运算数
我们定义了堆栈stack[MAX]后，就可以利用入栈操作存储先后输入的两个运算数。
下面看一下是如何实现的：
int push(int i) /*存储运算数，入栈操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/
return 0;
}
else /*堆栈已满，给出错误信息，返回出错指示*/
{
printf("The stack is full");
return ERR;
}
}
我们在调用函数push时，如果它的返回值为0，说明入栈操作成功；否则，若返回值为ERR(在程序中说明为-1)，说明入栈操作失败。
3、从堆栈中取出运算数
当程序中读完了四则运算符后，我们就可以从堆栈中取出已经存入的两个运算数，构成表达式，计算出结果。取出运算数的函数采用的正是出栈算法。在本例中，实现该算法的函数 为pop():
int pop(); /*取出运算数，出栈操作*/
{
int var; /*定义待返回的栈顶元素*/
if(top!=NULL) /*堆栈中仍有数据元素*/
{
var=stack[top--]; /*堆栈指示下移一个位置*/
return var;
}
else /*堆栈为空，给出错误信息，并返回出错返回值*/
printf("The stack is cmpty!\n");
return ERR;
}
同样，如果堆栈不为空，pop()函数返回堆栈顶端的数据元素，否则，给出栈空提示，并返回错误返回值ERR。
4、设计完整的后缀式计算器
有了堆栈存储运算数，后缀式计算器的设计就很简单了。程序首先提示用户输入第一个运算数，调用push()函数存入堆栈中；而后提示用户输入第二个运算数，同样调用push()函数存入堆栈中。接下来，程序提示用户输入+,-,*,/四种运算符的一种，程序通过switch_case结构判断输入运算符的种类，转而执行不同的处理代码。以除法为例，说明程序的执行流程：
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\nThe result is %d\n",c);
printf("\n");
break;
程序判断用户输入的是除号后，就执行上述代码。首先接连两次调用pop()函数从堆栈中读出先前输入的运算数，存入整型数a和b中；然后执行除法运算，结果存入单元c中。这时需要考虑究竟谁是被除数，谁是除数。由于开始我们先将被除数入栈，根据堆栈“先进后出”的原则，被除数应该是第二次调用pop()函数得到的返回值。而除数则是第一次调用pop()函数得到的返回值。
最后程序打印出运算结果，并示提示用户是否继续运行程序：
printf("\t Continue?(y/n):");
l=getche();
if(l=='n')
exit(0);
如果用户回答是"n"，那么结束程序，否则继续循环。
完整的程序代码如下：
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define ERR -1
#define MAX 100 /*定义堆栈的大小*/
int stack[MAX]; /*用一维数组定义堆栈*/
int top=0; /*定义堆栈指示*/
int push(int i) /*存储运算数,入栈操作*/
{
if(top<MAX)
{
stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/
return 0;
}
else
{
printf("The stack is full");
return ERR;
}
}
int pop() /*取出运算数，出栈操作*/
{
int var; /*定义待返回的栈顶元素*/
if(top!=NULL) /*堆栈中仍有元素*/
{
var=stack[top--]; /*堆栈指示下移一个位置*/
return var; /*返回栈顶元素*/
}
else
printf("The stack is empty!\n");
return ERR;
}
void main()
{
int m,n;
char l;
int a,b,c;
int k;
do{
printf("\tAriothmatic Operate simulator\n"); /*给出提示信息*/
printf("\n\tPlease input first number:"); /*输入第一个运算数*/
scanf("%d",&m);
push(m); /*第一个运算数入栈*/
printf("\n\tPlease input second number:"); /*输入第二个运算数*/
scanf("%d",&n);
push(n); /*第二个运算数入栈*/
printf("\n\tChoose operator(+/-/*//):");
l=getche(); /*输入运算符*/
switch(l) /*判断运算符，转而执行相应代码*/
{
case '+':
b=pop();
a=pop();
c=a+b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '-':
b=pop();
a=pop();
c=a-b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '*':
b=pop();
a=pop();
c=a*b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
case '/':
b=pop();
a=pop();
c=a/b;
printf("\n\n\tThe result is %d\n",c);
printf("\n");
break;
}
printf("\tContinue?(y/n):"); /*提示用户是否结束程序*/
l=getche();
if(l=='n')
exit(0);
}while(1);
}
:
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //初始分配量
#define STACKINCREMENT 10 //存储空间的分配增量
typedef char ElemType;
typedef ElemType OperandType; //操作数
typedef char OperatorType;
typedef struct
{
ElemType *base;
ElemType *top;
int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{
//构造一个空栈S
S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status GetTop(SqStack S){
ElemType e;
if (S.top == S.base) return ERROR;
e = *(S.top-1);
return e;
}
Status Push (SqStack &S,ElemType e)
{
//插入元素e为新的栈顶元素
if (S.top - S.base >= S.stacksize){
S.base = (ElemType *) realloc ( S.base,
(S.stacksize + STACKINCREMENT) * sizeof(ElemType));
if(!S.base) exit (OVERFLOW);
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return OK;
}
Status Pop (SqStack &S,ElemType &e){
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(S.top == S.base) return ERROR;
e = * --S.top;
return OK;
}
char In(char c,char OP[])
{
if(c>=35 && c<=47)
return 1;
else return 0;
}
char OP[8]=;
int m[7][7]={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};//1 > 2 < 0 = -1 不存在
char Precede(char i,char j)
{
int a,b; char *p;
for(p=OP,a=0;*p!='\0';p++,a++)
if(*p==i) break;
for(p=OP,b=0;*p!='\0';p++,b++)
if(*p==j) break;
if(m[a][b]==1) return '>';
else if(m[a][b]==2) return '<';
else if(m[a][b]==0) return '=';
else return 'O';
}
char Operate(char a,char theta,char b)
{
if(a>47) a=atoi(&a);
if(b>47) b=atoi(&b);
switch(theta)
{
case '+': return a+b;
break;
case '-': return a-b;
break;
case '*': return a*b;
break;
case '/': return a/b;
break;
}
}
OperandType EvaluateExpression()
{
SqStack OPTR,OPND;
OperandType a,b,c; OperatorType theta;
InitStack(OPTR); Push(OPTR,'#');
InitStack(OPND); c=getchar();
while (c!='#' || GetTop(OPTR)!='#')
{
if (!In(c,OP))
else
switch(Precede(GetTop(OPTR),c))
{
case '<' :
Push(OPTR,c); c = getchar();
break;
case '=' :
Pop(OPTR,c); c = getchar();
break;
case '>' :
Pop(OPTR,theta);
Pop(OPND,b); Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}
}
return GetTop(OPND);
}
void main()
{
printf("(以#为结束符)\n");
printf("请输入：\n");
int a;
a=(int)EvaluateExpression();
printf("%d",a);
getch();
}
:
ls都正确
:
C++ In Action这本书里面有表达式求值的详细项目分析.
:
数据结构的书里面都有的,仔细看一下
:
studyall123的只能对0到9的数字运算才有效,对于10以上的数字就不行!不知道有没有更好的方法!
:
现在的人，连google一下都懒啊
:
实际上是按照逆波兰式的顺序让输入的表达式入栈，再根据运算符优先级来计算。
:
lenrning!
❹ 数据结构：C语言描述栈的应用——算符优先法求中缀表达式的值
#include"iostream.h"
#include"math.h"
#include"stdlib.h"
class Calculator
{
public:
//接口方法声明
void Run();
private:
//辅助函数
bool IsOperator(char ch);//判断字符ch是否为操作符
char Precede(char theta1,char theta2);//判断相继出现的theta1和theta2的优先级
double Operate(double left,char theta,double right,int[] &a);//执行运算letf theta right
void Get2Operands(LinkStack<double>&opnd,double &left,double &right);
//从栈opnd中退出两个操作数
};
void Calculator::Get2Operands(LinkStack <double>&opnd,double &left,double &right)
{
}
bool Calculator:: IsOperator(char ch)
{
char ch;
cin>>ch;
if(ch=='+'||ch=='-'||ch=='*'||ch=='/'ch=='('ch==')'||ch=='=')
return true;
else
return false;
}
char Calculator:: Operate(double left,char theta,double right)
{ double result;
switch(theta)
{
case'+':result=left+right;break;
case'-':result=left-right;break;
case'*':result=left*right;break;
case'/':result=left/right;break;
}
return result;
}
char Calculator:: Precede(char theta1,char theta2)
{
char ch;
switch(theta1)
{
case'+':
case'-':
{
switch (theta2)
{
case'+':
case'-':
case')':
case'=':
ch='>';
break;
case'*':
case'/':
case'(':
ch='<';
break;
}
break;
}
case'*':
case'/':
{
if(theta2=='(')
ch='<';
else
ch='>';
break;
}
case'(':
{
if(theta2==')')
ch='=';
else ch='<';
break;
}
case')':
{
ch='>';
break;
}
case'=':
{
if(theta2=='=')
ch='=';
else
ch='<';
break;
}
}
return ch;
}
//方法Run()算法实现如下
void Calculator::Run()
{//操作结果:按算符优先法进行表达式求值计算
LinkStack<double> opnd; //操作数栈
LinkStack<char>optr; //操作符栈
optr.push('='); //在optr栈中加入一个'='
char ch; //临时字符
char optrTop; //临时optr栈栈顶字符
double operand; //操作数
char theta; //操作符
cin>>ch; //从输入流获取一字符ch
while((optr.Top(optrTop),optrTop!='=')||ch!='=')
{
if(!IsOperator(ch))
{//ch不是操作字符
cin.putback(ch); //将字符放ch回输入流
cin>>operand; //读操作数operand
opnd.Push(operand); //进入opnd栈
cin>>ch; //读入下一字符ch
}
else
{//ch是操作符
switch(Precede(optrTop,ch))
{
case'<':
optr.Push(ch);
cin>>ch;
break;
case'=':
optr.Pop(optr Top);
cin>>ch;
break;
case'>':
double left,right;
Get2Operands(opnd,left,right);
optr.Pop(theta);
opnd.Push(Operate(left,theta,right));
break;
case'e':
cout<<"操作符匹配出错"<<endl;
exit(2);
}
}
}
opnd.Top(operand);
cout<<"表达式值为:"<<operand<<endl;
}
void main(void)
{
system("pause");
return 0;
}
❺ 计算器把中缀表达式转换为后缀表达式的原理是什么不要代码,求解答
假设一个二叉树以中根顺序入栈,从栈结构看:
1.入栈前输出结果:前缀表达
2.第一次出栈时输出:中缀表达
3.第二次出栈时输出:后缀表达
入栈算法:
void visit{Node p)
while (p!=null){
(1)
push(p);
visit(p.left);
pop(p);
(2)
push(p);
visit(p.right);
pop(p);
(3)
}
}
分别在(1)(2)(3)处输出可得到前根,中根和后根遍历
对我有用[0] 丢个板砖[0] 引用 | 举报 | 管理
关注
antimatterworld
antimatterworld
等级：
#6 得分：0回复于： 2009-03-19 10:58:28
楼上仁兄厉害
俺再研究研究...
对我有用[0] 丢个板砖[0] 引用 | 举报 | 管理
关注
ToBeTough
ToBeTough
等级：
#7 得分：0回复于： 2009-03-20 07:20:22
引用 5 楼 njwangchuan 的回复:假设一个二叉树以中根顺序入栈,从栈结构看:
1.入栈前输出结果:前缀表达
2.第一次出栈时输出:中缀表达
3.第二次出栈时输出:后缀表达
入栈算法:
void visit{Node p)
while (p!=null){
(1)
push(p);
visit(p.left);
pop(p);
(2)
push(p);
visit(p.right);
pop(p);
(3)
}
}
分别在(1)(2)(3)处输出可得到前根,中根和后根遍…
❻ C语言问题 用一个栈来存符号把数学的中缀表达式计算出来
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX 100
typedef struct
{
int data[MAX];
int top;
}SeqStack;
SeqStack *Init_SeqStack() //初始化堆栈
{
SeqStack *s;
s=new SeqStack; //申请栈空间
if (!s)
{
printf("空间不足，初始化失败！");
return NULL; //未申请到足够大的存储空间，返回空指针
}
else
{
s->top=-1; //初始化栈顶指针
printf("堆栈初始化成功!\n按回车键继续...");
return s; //申请到栈空间，返回栈空间地址
}
}
int Empty(SeqStack *s){ //判空栈
if (s->top==-1)
return 1; //栈顶指针指向栈底，空栈
else
return 0;
}
int Push(SeqStack *s,int x){ //进栈
if (s->top==MAX-1)
return 0; //栈满不能入栈，返回错误代码0
else
{ s->top++; //栈顶指针向上移动
s->data[s->top]=x; //将x至入新的栈顶
return 1; //入栈成功，返回成功代码1
}
}
int Pop(SeqStack *s,int *x){ //出栈
if (Empty(s))
return 0; //栈空不能出栈，返回错误代码0
else
{ *x=s->data[s->top]; //保存栈顶元素值
s->top--; //栈顶指针向下移动
return 1; //返回成功代码1
}
}
int GetTop(SeqStack *s) //取栈顶元素
{
return(s->data[s->top]);
}
int Is_OPND(char x)//判断运算符和运算数
{
int temp;
temp=1;
switch (x)
{
case '^':
case '*':
case '/':
case '%':
case '+':
case '-':
case '(':
case ')':
case '#':temp=0;
}
return(temp);
}
int Precede(char in,char out)
{
int c_temp1,c_temp2;
int temp;
switch(in)
{
case '^':c_temp1=5;break;
case '*':
case '/':
case '%':c_temp1=4;break;
case '+':
case '-':c_temp1=2;break;
case '(':c_temp1=0;break;
case ')':c_temp1=6;break;
case '#':c_temp1=-1;
}
switch(out)
{
case '^':c_temp2=5;break;
case '*':
case '/':
case '%':c_temp2=3;break;
case '+':
case '-':c_temp2=1;break;
case '(':c_temp2=6;break;
case ')':c_temp2=0;break;
case '#':c_temp2=-1;
}
if (c_temp1<c_temp2) temp=-1;//栈外算符优先级高，入栈
if (c_temp1==c_temp2) temp=0;
if (c_temp1>c_temp2) temp=1;//栈内算符优先级高，运算
return(temp);
}
int Execute(int a, char op, int b){
int s;
switch(op){
case '^':s=(int)pow(a,b);break;
case '*':s=a*b;break;
case '/':s=a/b;break;
case '%':s=a%b;break;
case '+':s=a+b;break;
case '-':s=a-b;break;
}
return(s);
}
void main()
{
SeqStack *OPTR, *OPND;//定义两个栈
int w,op,temp;
int a,b,is_err;
OPTR=Init_SeqStack(); //初始化运算符optr堆栈
OPND=Init_SeqStack(); //初始化运算数opnd堆栈
is_err=Push(OPTR,'#'); //首先将#进运算符栈
system("cls");
printf("------------------中缀表达式求值程序------------------\n\n");
printf("-----使用方法：连续输入表达式，以#号结束，最后按回车键。\n\n");
printf("-----可使用的运算符包括：(、)、^、*、/、%、+、-\n\n");
printf("-----注意：运算数为0-9十个数字。\n\n");
printf("-----请输入表达式：");
w=getchar();
while(w!='#'||GetTop(OPTR)!='#')//算符栈顶元素不是#（表达式非0，执行语句）
{
if (Is_OPND(w))//w为数值，返回1，w为算符，返回0
{
Push(OPND,w-'0');//数值进opnd堆栈
w=getchar();//循环
}
else
switch(Precede(GetTop(OPTR),w))//否则，比较optr堆栈中栈顶的算符与getchar()函数读入的算符的优先级
{
case -1://栈外算符优先级高，继续入栈
is_err=Push(OPTR,w);//入栈操作
w=getchar();//循环
break;
case 0://???
is_err=Pop(OPTR,&temp);
w=getchar();
break;
case 1://栈内算符优先级高
is_err=Pop(OPND,&b);//将栈顶的元素赋予后一个变量
is_err=Pop(OPND,&a);
is_err=Pop(OPTR,&op);
is_err=Push(OPND,Execute(a,op,b));
break;
}
}
printf("-----结果为：%d\n",GetTop(OPND));
加分
❼ 栈表示中缀表达式转后缀表达式
内存中的两种存储区
1..栈的特点是 容量小 速度快 适合存放小型数据 如基本数据类型和对象类型的引用
在栈中变量直接指向存放变量值的空间 对于对象引用则存放对象在堆中的内存地址
2..堆的特点和栈相反 因此适合存放对象本身
3..对象引用访问对象的原理是 先通过该引用找到栈中的数据 即对象的地址 在通过该
地址访问对象 这就是为什么 对象 a=null; 调用a.方法(属性) 会引发异常 因为找不到
实际对象的地址 向一个不存在的对象发送消息 如同叫一个不存在的人去帮你做事
程序不崩溃才怪
❽ c++用栈编写一个中缀表达式转换为前缀表达式的程序
#include<string>
#include<iostream>
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;
}
自己编译吧
❾ 使用栈计算表达式的值（用中缀表达式）数据结构 C++版写，急！!
我们现在所写的表达值就是中缀。
中缀难啊。后缀就写了一个，只不过是C版的。
❿ 写出对应的中缀算术表达式
(24+8)*3/4*(10-7)