后缀表达式的计算

后缀表达式的计算
后缀表达式的计算

江南大学物联网工程学院上机报告
课程名称 班 级 数据结构 上机名称 姓 名 后缀表达式的计 算 上机日期 学 号 2016.3.18 上机报告要求 1.上机名称 2.上机要求 3.上机环境 4.程序清单(写明运行结果) 5.上机体会
1.上机名称
后缀表达式的计算
2.上机要求
按常规形式输入算术表达式(例如:输入2*(6-4)+8/4) ,要求能够: ⑴生成表达式的后缀表示,并输出; ⑵基于表达式的后缀表示,对该表达式求值; ⑶编写一个主程序对表达式求值函数进行测试。
3.上机环境
Visual C++ 6.0
4.程序清单(写明运行结果)
#include #include #include #define ERROR 0 #define OK 1 #define N 50 #define STACK_INT_SIZE 10 #define Queue_Size 20 typedef int ElemType; typedef struct { char Qdata[Queue_Size]; int front,rear; }SeqQueue; typedef struct { ElemType *base; ElemType *top; int stacksize; }SqStack; SqStack OPTR,OPND; SeqQueue SeQ;

char PreTab[7][7]={ {'>','>','<','<','<','>','>'}, {'>','>','<','<','<','>','>'}, {'>','>','>','>','<','>','>'}, {'>','>','>','>','<','>','>'}, {'<','<','<','<','<','=','x'}, {'>','>','>','>','x','>','>'}, {'<','<','<','<','<','x','='} }; char *OpretorS="+-*/()#"; char *Express="2*(6-4)+8/4"; int InitStack(SqStack *S); int push(SqStack *S,ElemType *e); int Pop(SqStack *S); void initQueue(SeqQueue *Q) { Q->front=0; Q->rear=0; } int EnterQueue(SeqQueue *Q,char c) { if (Q->rear==Queue_Size) { printf("\n 队列满,无法入队!\n"); return ERROR; } Q->Qdata[Q->rear]=c; Q->rear++; return OK; } int OutQueue(SeqQueue *Q,char *e) { if(Q->front==Q->rear) { printf("\n 队列空,无法出队!\n"); return ERROR; } *e=Q->Qdata[Q->front++]; return OK; } int InitStack(SqStack *S) { S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base)

return ERROR; S->top=S->base; S->stacksize=STACK_INT_SIZE; return OK; } int Push(SqStack *S,ElemType e) { if ((S->top-S->base)>STACK_INT_SIZE) return 0; *S->top=e; S->top++; return OK; } int Pop(SqStack *S) { int e; if (S->top==S->base) return 0; S->top--; e=*S->top; return *S->top; } int IsOps(char c) { int i=0; char *p; p=OpretorS; while(i<7) { if (*p++==c) break; i++; } return i; } char Precede(char c1,char c2) { int i,j; i=IsOps(c1); j=IsOps(c2); if ( PreTab[i][j]=='x') return 0; return PreTab[i][j]; } int Operate(int a,char TheOp,int b) { switch(TheOp) {

case'+':return a+b; case'-':return a-b; case'*':return a*b; case'/':return a/b; } return 0; } int f(char c) { int f=-1; switch(c) { case'+': case'-':f=1;break; case'*': case'/':f=2;break; default:f=0;break; } return f; } int Operator(char c) { if(c=='+'||c=='-'||c=='*'||c=='/') return 1; else return 0; } void convert(char s[N]) { char p[N],stack[N]; int i,top=0,j=0, len=0; if(s[0]==')') { printf("算术表达式错误!"); printf("\n"); } else { while(s[len]!='\0') { len++; } for(i=len-1;i>=0;) { if(s[i]>=48&&s[i]<=57) {

p[j]=s[i]; j++; } if(s[i]==')') { top++; stack[top]=s[i]; } while(Operator(s[i])) { if(top==0||stack[top]==')'||f(s[i])>=f(stack[top])) { top++; stack[top]=s[i];break; } else { p[j]=stack[top]; top--; j++; } } if(s[i]=='(') { while(stack[top]!=')') { p[j]=stack[top]; top--;j++; } top--; } i--; } while(top!=0) { p[j]=stack[top]; j++; top--; } p[j]='\0'; printf("\n 前缀表达式为: "); for(;j>=0;j--) printf("%c",p[j]); printf("\n");

} } int main() { char *ScanChar; char c1,c; char TheOp; int b,a,digit; InitStack(&OPTR); Push(&OPTR,'#'); InitStack(&OPND); initQueue(&SeQ); ScanChar=Express; c=*ScanChar; while(c!='#'||*OPTR.top!='#') { if (c==0) c='#'; if (IsOps(c)>=7) { digit=c-'0'; Push(&OPND,digit); EnterQueue(&SeQ,c); c=*++ScanChar; } else { c1=*(OPTR.top-1); switch(Precede(c1,c)) { case'<':Push(&OPTR,c); c=*++ScanChar;break; case'=':TheOp=Pop(&OPTR); if(c!=0&&c!='#') c=*++ScanChar;break; case'>':TheOp=Pop (&OPTR ); EnterQueue(&SeQ,TheOp); b=Pop(&OPND);a=Pop(&OPND); Push(&OPND,Operate(a,TheOp,b));break; default:printf("\n 算术表达式错误!\n"); return ERROR; } } } printf("算术表达式为:%s \n 后缀表达式为:",Express); while(SeQ.rear-SeQ.front!=0)

{ OutQueue(&SeQ,&c); printf("%c",c); } convert(Express); printf("其结果为:%d\n",Pop(&OPND)); return 0; }
5.上机体会
这次的上机实验感觉有点难,从上机课上的时候只有几个人交就可以看出来一些。自己花了许多的精力然 而一开始还是没完成全部的要求,只写完了一部分即中缀转后缀表达式的部分,中缀转前缀的表达式在这 一周内才勉勉强强写完。另外,这次上机实验也让我意识到,有时我们也需要参考一下别人所写的程序, 看看别人的思路,也许某种时刻,别人的程序会开阔你的思路,同时我们还需要和同学多交流交流,讨论 一下自己关于某个问题的看法想法什么的,来更好的促进自己关于数据结构的学习。还有,感觉学数据结 构特别需要坚持,有时, 关于某一问题想了很久还是想不通时特别想要放弃, 这时, 坚持就显得尤为重要, 也许,你再坚持一会,向前迈进一步,胜利就在向你招手。
教师评价



及 格
不 及 格
教师 签名
日 期

后缀表达式求值

一、设计思想 首先,将中缀表达式转换为后缀表达式。转换算法思路:设中缀表达式已存入数组E[n];由于后缀表达式中操作数的次序与中缀表达式一致,故扫描到中缀表达式操作数时直接输出到B[n]即可;对于运算符,视其优先级别,优先级高的运算符先输出;设一存放运算符的栈s,先将s置空;依次扫描E[n]中各分量E[i]送x: 若x=“”(结束符),依次输出栈s中运算符,转换结束; 若x=操作数,直接输出x到B[n]中; 若x=‘)’,反复退栈输出栈s中子表达式运算符,直到栈顶符=‘(’,并退掉栈顶的‘(’; 若x=操作符,反复退栈输出栈s中运算符,直到栈顶符

三、源代码 下面给出的是用后缀表达式求值算法实现的程序的源代码: #include #include #define MaxSize 50 struct { char data[MaxSize]; int top; } op;//定义栈; struct { float data[MaxSize]; int top; } st; //中缀转换为后缀 void trans(char*exp,char*postexp) { int i=0; op.top=-1; while(*exp!='\0') { switch(*exp) { case'(': op.top++;op.data[op.top]=*exp; exp++;break; case')': while(op.data[op.top]!='(') { postexp[i++]=op.data[op.top]; op.top--; } op.top--;exp++;break; case'+': case'-': while(op.top!=-1&&op.data[op.top]!='(') { postexp[i++]=op.data[op.top]; op.top--; }

(完整版)数学表达式计算(c语言实现)

一、设计思想 计算算术表达式可以用两种方法实现: 1.中缀转后缀算法 此算法分两步实现:先将算术表达式转换为后缀表达式,然后对后缀表达式进行计算。具体实现方法如下: (1)中缀转后缀 需要建一个操作符栈op和一个字符数组exp,op栈存放操作符,字符数组用来存放转换以后的后缀表达式。首先,得到用户输入的中缀表达式,将其存入str数组中。 对str数组逐个扫描,如果是数字或小数点,则直接存入exp数组中,当扫描完数值后,在后面加一个#作为分隔符。 如果是操作符,并且栈为空直接入栈,如果栈不为空,与栈顶操作符比较优先等级,若比栈顶优先级高,入栈;如果比栈顶优先级低或相等,出栈将其操作符存到exp数组中,直到栈顶元素优先等级低于扫描的操作符,则此操作符入栈;如果是左括号,直接入栈,如果是右括号,出栈存入exp数组,直到遇到左括号,左括号丢掉。然后继续扫描下一个字符,直到遇到str中的结束符号\0,扫描结束。结束后看op栈是否为空,若不为空,继续出栈存入exp数组中,直到栈为空。到此在exp数组最后加结束字符\0。 我们就得到了后缀表达式。 (2)后缀表达式计算 此时需要一个数值栈od来存放数值。对exp数组进行逐个扫描,当遇到数字或小数点时,截取数值子串将其转换成double类型的小数,存入od栈中。当遇到操作符,从栈中取出两个数,进行计算后再放入栈中。继续扫描,知道扫描结束,此时值栈中的数值就是计算的结果,取出返回计算结果。 2.两个栈实现算法 此算法需要两个栈,一个值栈od,一个操作符栈op。将用户输入的数学表达式存入str数组中,对其数组进行逐个扫描。 当遇到数字或小数点,截取数值子串,将其转换成double类型的数值存入od栈中; 当遇到左括号,直接入op栈;遇到右括号,op栈出栈,再从值栈od中取出两个数值,计算将其结果存入值栈中,一直进行此操作,直到操作符栈栈顶为左括号,将左括号丢掉。 如果遇到操作符,若op栈为空,直接入栈;若栈不为空,与栈顶元素比较优先等级,若比栈顶操作符优先等级高,直接入op栈,如果低于或等于栈顶优先等级,op栈出栈,再从值栈中取出两个数值,计算将其结果存入值栈中,一直进行此操作,直到栈顶优先等级低于扫描的操作符等级,将此操作符入op栈。继续扫描直到遇到str中的结束字符\0,扫描结束。此时看操作符栈是否为空,若不为空,出栈,再从值栈中取出两个数值进行计算,将其结果存入值栈,一直进行此操作,直到操作符栈为空。此时把值栈中的数值取出,即为所得的最终计算结果。 二、算法流程图 第一种算法:中缀转后缀算法

C语言 后缀表达式计算

一、设计思想 计算算数表达式并求值,采取的共有两种方法: 1.先将算数表达式转化为后缀表达式,然后对后缀表达式进行计算。 2.对算数表达式进行直接的计算。 第一种算法 这种解决方案又分为两步: 1.将表达式先转化为后缀表达式的字符串数组 2.利用后缀表达式进行计算 在转化过程中,第一,建立一个存符号的栈,和一个字符串数组,用来存放转化以后的表达式 然后,对于得到的用户输入的字符串进行逐个的扫描,如果是数组或者小数点,则直接存放到数组中,并且在后面加入一个分隔符,如果是操作符,则和栈中的已存的进行比较,如果比栈中的操作符的优先级高,则直接入栈,如果优先级低或相等,则栈中元素出栈,存到字符串中,然后再次检查栈顶,直到栈中元素的优先级低于扫描操作符,则此操作符入栈,然后扫描下一个字符,直到遇到字符串的结束符号\0,扫描结束。数组中存的就是后缀表达式。得到后缀表达式后,进行计算,要用到数值栈。首先要将字符表示的数字转化为浮点小数,然后进行扫描,遇到数值,放入栈中,遇到操作符,就从栈中取出两个数,进行计算后再放入栈中,扫描下一个,最后的计算结果就存到了栈中,直接取出栈内元素,就是计算的最后结果。 第二种算发 首先要建立两个栈,一个用来存放操作符,一个用来存放数值。开始对用户输入的字符串进行扫描,如果是数字字符或者小数点,则将字符转化为浮点数存到数栈里,如果是操作符,则观察符号栈,如果栈顶元素的优先级低于观察的操作符,则操作符入栈,如果栈顶元素的优先级高于或者等于观察的操作符,则从数值栈中取出两个浮点数,从符号栈中取出栈顶的操作符,然后进行相应的数值计算,所得的结果再存到数值栈中,重复这样的操作,直到符号栈中栈顶元素的优先级低于观察的操作符,则此操作符入栈,然后对下一个字符进行扫描。如果是左括号,则不进行优先级的比较,直接入栈,入栈后优先级为-1。如果是右括号,则从数值栈中取两个操作数,符号栈中取出一个符号,然后进行计算后得数放入数栈中,不断进行此类操作,直到从栈中取出的是左括号为止,左括号去掉,扫描下一个。扫描结束后,计算也结束了,计算的结果就存放在数值栈中,最后把数值栈中的数取出,就是所得的计算结果。 容错的算法简要: 括号匹配:当扫描到左括号是,左括号直接入栈,扫描到右括号时,则左括号出栈,如果栈为空,则右括号多,如果最后栈中还有括号,则左括号多。给出错误提示。 除数不为0:当扫描到'/'时,就判断其后面的数字是否为0,如果为0报错。 取余运算:取余运算时,操作数判断是否为整数,不为整数报错。 二、算法流程图 第一种算法:先将表达式转化为后缀表达式,然后计算 其主函数流程图为:

谭浩强C语言总结

谭浩强C语言总结Revised on November 25, 2020

《C语言程序设计》课程设计报告 第一部分《C语言程序设计》知识点梳理 (注《C语言程序设计》所涉及到的重要知识点及对这些知识点的理解) 一、程序设计 1、计算机语言 (1)机器语言 (2)汇编语言 为客服机器语言的缺点,用符号语言来表示指令(英文字母、数字)的符号语言为符号汇编语言(又称低级语言)。一条符号语言指令对应转换为一条机器指令;转换的过程称为“代真”或“汇编” (3)高级语言 客服低级语言的缺点,接近人们习惯用的自然语言和数学语言;用英语单词表示的指令及语句。功能性强,不依赖于具体机器,对任何型号计算机都适用(或做很少修改)。〔C语言、FORTRAN、QBASIC…〕 C语言特点①语言简洁、紧凑,使用方便、灵活②运算符丰富③数据类型丰富④具有结构化的控制语句⑤语法限制不太严格,程序设计自由度大⑥C语言允许直接访问物理地址,能进行位(bit)操作,能实现汇编语言的大部分功能,可以直接对硬件进行操作⑦用C语言编写的程序可移植性好⑧生成目标代码质量高,程序执行效率高 2、运行C程序的步骤及方法 ①上机输入和编辑源程序,以文件形式存档。 .c作为后缀,生成源程序文件

②对源程序进行编译。进行预处理,连接其它部分组成完整的、可进行正式编译的源程序(检查、转换) ③进行连接处理。把所有编译后得到的目标模块连接装配,与函数库想连接成一个整体,生成一个可供计算机执行的目标程序 ④运行可执行程序,得到运行结果。 二、算法 1、算法的概念 广义的说是解决一个问题所采用的方法和步骤(太极拳动作图解、乐谱)计算机算法分为两大类:1.数值运算算法(求数值解) 2.非数值运算算法(常用于事务管理领域) 2、算法的特性 ①有穷性:一个算法应包含有限的操作步骤 ②确定性:算法中的每一个步骤都应当是确定的,而不是含糊的、模棱两可的(算法的含义应当是唯一的,而不应当产生“歧义性”) ③有零个或多个输入:在执行算法时需要从外界取得必要的信息 ④有一个或多个输出: ⑤有效性:算法中的每一个步骤都应当有效的执行,并得到确定的结果 3、算法描述 (1)自然语言

后缀表达式求值的算法及代码

#include #include struct node // 栈结构声明 { int data; // 数据域 struct node *next; // 指针域 }; typedef struct node stacklist; // 链表类型 typedef stacklist *link; // 链表指针类型 link operand=NULL; // 操作数栈指针 link push(link stack,int value) // 进栈 { link newnode; // 新结点指针 newnode=new stacklist; // 分配新结点 if (!newnode) { printf("分配失败!"); return NULL; } newnode->data=value; // 创建结点的内容 newnode->next=stack; stack=newnode; // 新结点成为栈的开始return stack; } link pop(link stack,int *value) // 出栈 { link top; // 指向栈顶 if (stack !=NULL) { top=stack; // 指向栈顶 stack=stack->next; // 移动栈顶指针 *value=top->data; // 取数据 delete top; // 吸收结点 return stack; // 返回栈顶指针} else *value=-1; } int empty(link stack) // 判栈空 { if (stack!=NULL)

[java入门学习]第 3 章 运算符和表达式.

第 3 章运算符和表达式 运算符指明对操作数所进行的运算。按操作数的数目来分,可以有一元运算 符 (如 ++、--,二元运算符(如 +、>和三元运算符 (如?:,它们分别对应于一个、两个和三个操作数。对于一元运算符来说 ,可以有前缀表达式 (如++i 和后缀表达式 (如 i++,对于二元运算符来说则采用中缀表达式(如a+b。按照运算符功能来分,基本的运算符有下面几类 : 1.算术运算符 (+,-,*,/,%,++,-- 2.关系运算符 (>,<,>=,<=,==,!= 3.布尔逻辑运算符 (!,&&,|| 4.位运算符 (>>,<<,>>>,&,|,^,~ 5.赋值运算符 (=,及其扩展赋值运算符如+= 6.条件运算符 ( ?: 7.其它 (包括分量运算符·,下标运算符 [],实例运算符 instance of,内存分配运算符new,强制类型转换运算符(类型,方法调用运算符 ( 等 本章中我们主要讲述前6类运算符。 § 3.1算术运算符 算术运算符作用于整型或浮点型数据 ,完成算术运算。 一、二元算术运算符 如下表所示运算符用法描述 + op1+op2 加 - op1-op2 减 * op1*op2 乘 / op1/op2 除 % op1%op2 取模(求余

Java对加运算符进行了扩展,使它能够进行字符串的连接 ,如 "abc"+"de",得到 串 "abcde"。我们将在第七章中讲解。与C、 C++不同,对取模运算符%来说,其操作数可以为浮点数, 如 37.2%10=7.2。 二、一元算术运算符 如下表所示 : 运算符用法描述 + +op 正值 - -op 负值 ++ ++op,op++ 加1 -- --op,op-- 减1 i++与 ++i的区别 i++在使用i之后,使 i的值加 1,因此执行完 i++后,整个表达式的值为 i,而 i的值变为 i+1。 ++i在使用i之前,使 i的值加 1,因此执行完 ++i后 ,整个表达式和 i的值均为 i+1。 对 i--与 --i同样。 例 3.1.下面的例子说明了算术运算符的使用 public class ArithmaticOp{ public static void main( String args[] { int a=5+4; //a=9 int b=a*2; //b=18 int c=b/4; //c=4 int d=b-c; //d=14 int e=-d; //e=-14 int f=e%4; //f=-2 double g=18.4;

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

#include #include #include #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OK 1 #define OVERFLOW -2 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Selemtype; typedef int Status; #define MAX 50 char string1[MAX]; //定义两个字符串分别存放中缀表达式和后缀表达式char string2[MAX]; int result; typedef struct { Selemtype *base; //在构造之前和销毁之后,base的值为NULL Selemtype *top; //栈顶指针 int stacksize; //当前分配的存储空间,以元素为单位 }SqStack; Status InitStack(SqStack *S); Status Push(SqStack *S,Selemtype e); Status Pop(SqStack *S,Selemtype e); Status InitStack(SqStack *S) { //构造一个空栈S S->base=(Selemtype*)malloc(STACK_INIT_SIZE*sizeof(Selemtype)); if(!S->base) return OVERFLOW; //存储分配失败 S->top=S->base; S->stacksize=STACK_INIT_SIZE; return OK; } Status Push(SqStack *S,Selemtype e) { //插入元素e为新的栈顶元素 if(S->top-S->base>=S->stacksize)

c语言实现中缀,后缀,前缀表达式转换并求值

c语言实现中缀,后缀,前缀表达式转 换并求值 c语言实现中缀,后缀,前缀表达式转换并求值九#include #include #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)//新建一个空运算数栈{=(selemtype1 *)malloc(MAXNUM*sizeof(selemtype1));

=; if(!) printf(“出错:申请空间失败!\\n”); } void Push1(sqstack1 &s,selemtype1 &e)//运算数栈,入栈:插入元素e为新的栈顶元素{ if(>=MAXNUM) printf(“出错:表达式过长!1\\n”); *++ =e; } void GetTop1(sqstack1 s,selemtype1 &e)//运算数栈,用e返回栈顶元素{e=*(); } void Popopnd1(sqstack1 &s,selemtype1 &e) //运算数栈,退栈:删除栈顶元素,并用e返回其值{e=*--; } int stackempy1(sqstack1 s) //运算数栈,若为空栈返回1,否则返回0 {if(==) return 1; else return 0; } typedef char selemtype2;//定义运算符栈的结点类型typedef struct//定义运算符栈类型{selemtype2 *base; selemtype2 *top; }sqstack2; void InitStack2(sqstack2 &s)//新建一个空运算符栈{=(selemtype2 *)malloc(MAXNUM*sizeof(selemtype2)); =; if(!) printf(“出错:申请空间失败!

数据结构计算器(包括中缀转换后缀)课程设计报告

课程设计报告 题目:计算表达式的值 1.问题描述 对于给定的一个表达式,表达式中可以包括常数、算术运行符(“+”、“-”、“*”、“/”)和括号,编写程序计算表达式的值。 基本要求:从键盘输入一个正确的中缀表达式,将中缀表达式转换为对应的后缀表达式,并计算后缀表达式的值。对于表达式中的简单错误,能够给出提示,并给出错误信息;表达式中可以包括单个字母表示的变量。 测试数据:任意选取一个符合题目要求的表达式。 提高要求:(1)能够处理多种操作符。 (2)实现包含简单运算的计算器。 (3)实现一个包含简单运算和函数运算的计算器。 2.需求分析 (1)软件的基本功能 本软件实在win32工程下实现的带有界面和图标的功能较为齐全的计算器。 此计算器分三个方面进行计算,分别为数值表达式的计算,字母表达式的计算和函数计算。可由键盘或用鼠标点击按键输入带有数字或字母的中缀表达式,程序可以将输入的带有数字或字母的中缀表达式转换成对应的后缀表达式,并计算只含有数字的后缀表达式的值。本软件支持含小数、多位数等多种操作数的处理,可以计算含加、减、乘、除、百分号、求余、求幂,求阶乘,求三角函数的值等多种运算符和函数的表达式 (2)输入/输出形式 用户可通过打开图标弹出来的计算器界面任意点击操作。对于在输入时发生的简单错误,软件通过弹出对话框给出提示并且在提示错误的同时自动将用户的出错输入略去转化成正确的表达式进行计算,用户也可选择清楚操作然后重新输入a.对于数值和函数表达式软件会输出其表达式的后缀表达式和计算结果并保留六位小数; b.对于字母表达式因字母无法进行数值运算,软件仅输出其后缀表达式的值;清楚按钮可以清楚有已经输入或输出的数据从头计算; 软件窗口可实现最小化。并且输入编辑框可进行修改,复制,粘贴等操作,但后缀表达式和求值结果的编辑框中的内容不可修改,只能执行复制操作。

后缀表达式的计算

#include #include #include #include using namespace std; int priority(char op) //运算符的优先级 { switch(op) { case '(': return 0; break; case '+': case '-': return 1; break; case '*': case '/': return 2; break; default: return -1; break; } } bool IsOperator(char op) //是否为运算符 { if (op == '+' || op == '-' || op == '*' || op == '/') { return true; } return false; } void inTOpost(char s[],vector &v) //转为后缀表达式{ stack stk; int i = 0,len = strlen(s); while(i < len) { if(s[i] >= '0' && s[i] <= '9') {

v.push_back(s[i]); v.push_back(' '); } else if (s[i] == '(') { stk.push(s[i]); } else if (s[i] == ')') { while(stk.top() != '(') { v.push_back(stk.top()); v.push_back(' '); stk.pop(); } stk.pop(); } else if (IsOperator(s[i])) { if (!stk.empty()) { while(!stk.empty() && priority(s[i]) <= priority(stk.top())) { v.push_back(stk.top()); v.push_back(' '); stk.pop(); } } stk.push(s[i]); } i++; } while(!stk.empty()) { v.push_back(stk.top()); v.push_back(' '); stk.pop(); } } bool compute(vector s,int &res) //计算后缀表达式的值 { int i = 0,num; int len = s.size();

数学表达式解析(前缀中缀后缀)

它们都是对表达式的记法,因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同:前缀表达式的运算符位于与其相关的操作数之前;中缀和后缀同理。 举例: (3 + 4) × 5 - 6 就是中缀表达式 - × + 3 4 5 6 前缀表达式 3 4 + 5 × 6 - 后缀表达式 中缀表达式(中缀记法) 中缀表达式是一种通用的算术或逻辑公式表示方法,操作符以中缀形式处于操作数的中间。中缀表达式是人们常用的算术表示方法。 虽然人的大脑很容易理解与分析中缀表达式,但对计算机来说中缀表达式却是很复杂的,因此计算表达式的值时,通常需要先将中缀表达式转换为前缀或后缀表达式,然后再进行求值。对计算机来说,计算前缀或后缀表达式的值非常简单。 前缀表达式(前缀记法、波兰式) 前缀表达式的运算符位于操作数之前。 前缀表达式的计算机求值: 从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素op 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果。 例如前缀表达式“- × + 3 4 5 6”: (1) 从右至左扫描,将6、5、4、3压入堆栈; (2) 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素,注意与后缀表达式做比较),计算出3+4的值,得7,再将7入栈; (3) 接下来是×运算符,因此弹出7和5,计算出7×5=35,将35入栈; (4) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。 可以看出,用计算机计算前缀表达式的值是很容易的。 将中缀表达式转换为前缀表达式: 遵循以下步骤: (1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2; (2) 从右至左扫描中缀表达式; (3) 遇到操作数时,将其压入S2; (4) 遇到运算符时,比较其与S1栈顶运算符的优先级: (4-1) 如果S1为空,或栈顶运算符为右括号“)”,则直接将此运算符入栈; (4-2) 否则,若优先级比栈顶运算符的较高或相等,也将运算符压入S1; (4-3) 否则,将S1栈顶的运算符弹出并压入到S2中,再次转到(4-1)与S1中新的栈顶运算符相比较; (5) 遇到括号时:

中缀表达式转后缀表达式并计算结果(C语言版)

中缀表达式转后缀表达式 中缀表达式转后缀表达式的规则。 1.遇到操作数:直接输入到后缀表达式栈 2.遇到运算符,直接入操作符栈 3.遇到左括号:直接将其入栈 4.遇到右括号:执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。 5.遇到其他运算符:加减乘除:弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈 6.最终将操作符栈中的元素依次出栈,输出到后缀表达式栈。 以下是自己写的代码。亲测没有问题。(模拟一个计算器,可以带括号,中间可以空格,只支持整数输入,但是输出结果精确到小数后6位) #include "stdio.h" #define MAX_LEN 100 typedef struct cal{ unsigned char isOper;//是否是操作数1,操作符0.操作数 double Num; //值。或者是操作符的ASCII值 }STRUCT_CAL; #define IS_NUM 0x00 #define IS_OPER 0x01 STRUCT_CAL stackCal[MAX_LEN]; STRUCT_CAL stackCalBack[MAX_LEN]; unsigned char topCal; char stackOper[MAX_LEN]; unsigned char topOper; /***************************************************************** * 堆栈初始化 *****************************************************************/ void stackInit(void)

表达式用二叉树表示

数据结构程序报告(3) 2011.3.29

2. 需求分析: (1)功能:表达式可以用二叉树表示,对于简单的四则运算,请实现以下功能 【1】对于任意给出的前缀表达式(不带括号)、中缀表达式(可以带括号)或后缀表达式(不带括号),能够在计算机内部构造出一棵表达式二叉树,并且图示出来(图形的形式)。【2】对于构造好的内部表达式二叉树,按照用户的要求输出相应的前缀表达式(不带括号)、中缀表达式(可以带括号,但不允许冗余括)或后缀表达式(不带括号)。 提示:所谓中缀表达式中的冗余括号,就是去掉括号后不影响表达式的计算顺序。例如:“(c+b)+a”中的括号是冗余的,可以表示成不冗余的“c+b+a”。 (2)输入输出要求:请输入字符串表达式: 树形二叉树(图形显示) 中缀表达式为: 前缀表达式为: 后缀表达式为: 3.概要设计:(算法) 分成两部分完成: 【1】前缀、中缀、后缀表达式->二叉树表达式 前缀表达式->二叉树表达式:(a)碰到操作数则把其值赋给相应的新申请的二叉树结点,地址压栈;(b)碰到操作符则把其值赋给相应的新申请的二叉树,并从栈中弹出两个地址,分别作为其右指针和左指针,然后再把其地址压栈,最后一个地址即为二叉树的根结点地址。 中缀表达式->二叉树表达式:把中缀表达式转换成后缀表达式,然后再建立二叉树。

后缀表达式->二叉树表达式:(a)碰到操作数则把其值赋给相应的新申请的二叉树结点,若栈为空则地址压栈,若非空则取栈顶元素,若栈顶元素的左孩子为空则当前结点设为其左孩子,左孩子为满则设为其右孩子再压栈;(b)碰到操作数则把其值赋给相应的新申请的二叉树结点,取栈顶元素,若栈顶元素的左孩子为空则设为其左孩子,左孩子为满则设为其右孩子开始那个元素地址为根结点地址,开始时用变量root保存。 【1】二叉树表达式->前缀、中缀、后缀表达式 二叉树表达式->前缀表达式:对二叉树表达式进行前序遍历。 二叉树表达式->中缀表达式:对二叉树表达式进行中序遍历,若结点操作符的优先级高于其左或右子树,在打印相应的子树之前先打印开括号,在打印相应的子树最后在打印一个闭括号。 二叉树表达式->后缀表达式:对二叉树表达式进行后序遍历。

四则混合运算和后缀表达式

/// 四则混合运算。 波兰表达式。 逆波兰表达式(后缀表达式)生成算法: (1)构造一个运算符栈,此运算符在栈内遵循越往栈顶优先级越高的原则。 (2)读入一个用中缀表示法表示的简单算术表达式,为方便起见,认为地在字符串后面加入一个特殊字符“;”,并设其优先级为0。 (3)从左至右扫描该算术表达式的每一个字符,如果该字符是数字,则分析到该数字串的结束并将该数字串加入结果字符串,小数点亦算入数字串。 (4)如果该字符是运算符,则按如下操作:优先级高的放在前面,通过出入栈操作。 如果该字符是左括号“(”,则该字符直接压入运算符栈。 如果该字符是右括号“)”,则把运算符栈顶元素弹出直至第一次遇到左括号。如果该字符是算术运算符且其优先关系高于运算符栈顶的运算符,则将该运算符入栈。 否则,将栈顶的运算符从栈中弹出至结果字符串末尾,直至栈顶运算符的优先级低于当前运算符,并将该字符入栈。 (5)重复上述操作(3)-(4)直至扫描完整个简单算术表达式(遇到特殊字符“;”)。 如: 一般简单表达式:((4+5)*6-5)/2+3*2 逆波兰表达式:4 5 + 6 * 5 - 2 / 3 2 * + 步骤如下: 运算符栈结果字符串 第1步:; "" 第2步:;( "" 第3步:;(( "" 第4步:;(( "4" 第5步:;((+ "4 5" 第6步:;( "4 5 +" 第7步:;(* "4 5 +" 第8步:;(* "4 5 + 6" 第9步:;(- "4 5 + 6 *" 第10步:;(- "4 5 + 6 * 5" 第11步:; "4 5 + 6 * 5 -"

第12步:;/ "4 5 + 6 * 5 -" 第13步:;/ "4 5 + 6 * 5 - 2" 第14步:;+ "4 5 + 6 * 5 - 2 /" 第15步:;+ "4 5 + 6 * 5 - 2 / 3" 第16步:;+* "4 5 + 6 * 5 - 2 / 3" 第17步:;+* "4 5 + 6 * 5 - 2 / 3 2" 第18步:;+ "4 5 + 6 * 5 - 2 / 3 2 *" 第19步:; "4 5 + 6 * 5 - 2 / 3 2 * +" 其中运算符优先级如下: * / :2 + - :1 ;:0 逆波兰表达式求值算法: (1)构建一个操作数栈,类型为float; (2)依次扫描逆波兰表达式的每一项; (3)如果是数字串则压入操作数栈; (4)如果是运算符,则从操作数栈顶弹出两个操作数,与运算符进行运算,结果压入操作数栈。 (5)不断重复以上步骤直至扫描完逆波兰表达式。 (6)此时操作数栈必定只剩一个数据,即为逆波兰表达式的值,弹出输出。如:如上表达式计算结果为:30.5.

c语言实现一.二叉树操作 二.用栈实现算术表达式求值 课设报告

目录 题目一.二叉树操作(1)二.算术表达式求 (1) 一、课程设计的目的 (1) 二、课程设计的内容和要求 (1) 三、题目一设计过程 (2) 四、题目二设计过程 (6) 五、设计总结 (17) 六、参考文献 (18)

题目一.二叉树操作(1)二.算术表达式求 一、课程设计的目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程,为了让大家更好地理解与运用所学知识,提高动手能力,我们进行了此次课程设计实习。这次课程设计不但要求学生掌握《数据结构》中的各方面知识,还要求学生具备一定的C语言基础和编程能力。 (1)题目一的目的: 1、掌握二叉树的概念和性质 2、掌握二叉树的存储结构 3、掌握二叉树的基本操作 (2)题目二的目的: 1、掌握栈的顺序存储结构和链式存储结构 2、掌握栈的先进后出的特点 3、掌握栈的基本运算 二、课程设计的内容和要求 (1)题目一的内容和要求: 1、编写已知二叉树的先序、中序序列,恢复此二叉树的程序 2、编写求二叉树深度的程序 (2)题目二的内容和要求: 1、算术表达式由操作数、运算符和界限符组成。操作数是正整数,运算符为 加减乘除,界限符有左右括号和表达式起始 2、将一个表达式的中缀形式转化为相应的后缀形式 3、依据后缀表达式计算表达式的值

三、题目一设计过程 1、题目分析 现已知一棵二叉树的先序遍历序列和中序遍历序列,依次从先序遍历序列中取结点,由先序序列确定根结点(就是第一个字母),每次取出一个结点就与中序遍历的序列进行比较,当相等的时候,中序遍历序列就被分成以该结点为根的二叉树子树,该结点左部分为左子树,右部分为右子树,直到取完先序列里的所有结点,则二叉树构造完毕(树用链式存储结构存储),用递归实现! 由建好的二叉树,先判断这棵树是否为空,若不为空则找数的左子树,统计它的高度,然后找树的右子树,统计它的高度,比较左子树和右子树的高度,然后返回其中大的那个值加一,则求出数的高度。这里用递归实现! 2、算法描述 main ( )(主函数) 先构造一颗二叉树,初始化为空,用来存储所构造的二叉树,并输入一棵树的先序序列和中序序列,并统计这个序列的长度。然后调用实现功能的函数。 void CreateBiTree(BiTree *T,char *pre,char *in,int len)(由先序序列和中序序列构造二叉树) 根据前序遍历的特点, 知前序序列(pre)的首个元素(pre[0])为根(root), 然后在中序序列(in)中查找此根(pre[0]), 根据中序遍历特点, 知在查找到的根(root) 前边的序列为左子树, 后边的序列为右子树。设根前边有n个元素,则又有, 在前序序列中,紧跟着根(root)的n个元素序列(即pre[1...n]) 为左子树, 在后边的为右子树,而构造左子树问题其实跟构造整个二叉树问题一样,只是此时前序序列为pre[1...n]), 中序序列为in[0...n-1], 分别为原序列的子串, 构造右子树同样。这里用递归实现! int Depth(BiTree T)(求树的深度) 当所给的参数T是NULL时,返回0。说明这个树只有一个叶子节点深度为0,当所给的参数不是NULL时,函数调用自己看看这个参数的左分支是不是NULL,

将中缀表达式转换为后缀表达式并计算

《数据结构》实验报告 ◎实验题目:使用键盘输入表达式,计算表达式的值并输出;将表达式转化成后缀表达式输出,利用后缀表达式求表达式的值并输出。 ◎实验目的:使用栈的操作编写关于数据结构的程序。 ◎实验内容:写出程序并上机调试、通过。 一、需求分析 1、演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“请输入表达式”时输入中缀表达式。然后计算机终端输出转换后的后缀表达式及计算后的结果。 2、程序执行的命令包括: (1)构造链栈;(2)输入数据;(3)判断输入的表达式是否为非法表达式;(4)将中缀表达式转换为后缀表达式;(5)计算表达式的值;(6)输出。(7)结束 4、本程序能将中缀表达式转换为后缀表达式,并且能计算表达式的值。 5、输入及输出示例: 例1: 请输入表达式 6+3*(6+5) 后缀表达式:6 3 6 5 + * + 计算结果为:39 Press any key to continue 例2: 请输入表达式 6-3*(7+1 ERROR:表达式错误 Press any key to continue 二概要设计 1.基本操作 (1)、struct node 操作结果:创建结构体 (2)、int Searchexpression(char string1[]) 初始条件:表达式string1已经存在。 操作结果:判断表达式是否非法 (3)、struct node *Initialization() 操作结果:创建栈链。 (4)、struct node *assort(struct node *s) 初始条件:string1、string2已存在。

操作结果:将中缀表达式转换为后缀表达式并存在string2中。 (5)、struct node *calcolate(struct node *s) 操作结果:求出表达式的值 2、模块调用图 三详细设计 1、每个模块: (1) 定义结构体 struct node { char data; int num; struct node *next; }; (2) 判断表达式是否非法 int Searchexpression(char string1[]) { int i1,b1,b2; int m; m=strlen(string1); if(string1[0]<'0'||string1[0]>'9') { printf("ERROR:表达式缺操作数!\n");return(WRONG); } for(i1=0;i1<=m;i1++) { if(string1[i1]=='(') b1++; else if(string1[i1]==')') b2++; } if(b1!=b2) {printf("ERROR:缺少括号\n");return(WRONG);} for(i1=0;i1

数学表达式解析汇报(前缀、中缀、后缀)

前缀、中缀、后缀表达式 它们都是对表达式的记法,因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同:前缀表达式的运算符位于与其相关的操作数之前;中缀和后缀同理。 举例: (3 + 4) × 5 - 6 就是中缀表达式 - × + 3 4 5 6 前缀表达式 3 4 + 5 × 6 - 后缀表达式 中缀表达式(中缀记法) 中缀表达式是一种通用的算术或逻辑公式表示方法,操作符以中缀形式处于操作数的中间。中缀表达式是人们常用的算术表示方法。 虽然人的大脑很容易理解与分析中缀表达式,但对计算机来说中缀表达式却是很复杂的,因此计算表达式的值时,通常需要先将中缀表达式转换为前缀或后缀表达式,然后再进行求值。对计算机来说,计算前缀或后缀表达式的值非常简单。 前缀表达式(前缀记法、波兰式) 前缀表达式的运算符位于操作数之前。 前缀表达式的计算机求值: 从右至左扫描表达式,遇到数字时,将数字压入堆栈,遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算(栈顶元素 op 次顶元素),并将结果入栈;重复上述过程直到表达式最左端,最后运算得出的值即为表达式的结果。 例如前缀表达式“- × + 3 4 5 6”: (1) 从右至左扫描,将6、5、4、3压入堆栈; (2) 遇到+运算符,因此弹出3和4(3为栈顶元素,4为次顶元素,注意与后缀表达式做比较),计算出3+4的值,得7,再将7入栈; (3) 接下来是×运算符,因此弹出7和5,计算出7×5=35,将35入栈; (4) 最后是-运算符,计算出35-6的值,即29,由此得出最终结果。 可以看出,用计算机计算前缀表达式的值是很容易的。 将中缀表达式转换为前缀表达式: 遵循以下步骤: (1) 初始化两个栈:运算符栈S1和储存中间结果的栈S2; (2) 从右至左扫描中缀表达式; (3) 遇到操作数时,将其压入S2; (4) 遇到运算符时,比较其与S1栈顶运算符的优先级: (4-1) 如果S1为空,或栈顶运算符为右括号“)”,则直接将此运算符入栈;

后缀表达式的算法和实现

数据结构—中缀表达式转后缀表达式算法及实现—栈的应用—计算表达式(C++代... 理论:(这部分很重要,看明白了,可以写出实现算法) 表达式的表示形式有中缀、前缀和后缀3中形式。中缀表达式按操作符的优先级进行计算(后面代码实现只包括+、-、*、\,小括号),即数学运算。后缀表达式中只有操作数和操作符。操作符在两个操作数之后。它的计算规则非常简单,严格按照从左到右的次序依次执行每一个操作。每遇到一个操作符,就将前面的两个数执行相应的操作。 由后缀表达式计算中缀表达式原理:计算机处理后缀表达式求值问题是比较方便的,即将遇到的操作数暂存于一个操作数栈中,凡是遇到操作数,便从栈中pop出两个操作数,并将结果存于操作数栈中,直到对后缀表达式中最后一个操作数处理完,最后压入栈中的数就是后最表达式的计算结果。 中缀表达式转换为等价的后缀表达式 中缀表达式不方便与计算机处理,通常要讲中缀表达式转换为一个与之等价的后缀表达式。等价是指两个表达式的计算顺序和计算结果完全相同。 中缀表达式:0.3/(5*2+1)# 的等价后缀表达式是:0.3 5 2 * 1 + /# 仔细观察这两个等价的表达式可知,操作数的出现次序是相同的,但运算符的出现次序是不同的。在后缀表达式中,运算符的出现次序是实际进行操作的次序;在中追表达式中,由于受到操作符的优先级和括号的影响,操作符出现次序与实际进行操作的次序很可能是不一样的。

算法描述: 将中缀表达式转换为等价的后缀表达式的过程要使用一个栈放“(”,具体可以按照下面的方式进行。 (1)从左到右一次扫描中缀表达式的每一个字符,如果是数字字符和圆点“.”则直接将它们写入后缀表达式中。 (2)如果遇到的是开括号“(”,则将它们压入一个操作符栈(不需要与栈顶操作符相比较),它表明一个新的计算层次的开始,在遇到和它匹配的闭括号“)”时,将栈中的元素弹出来并放入后缀表达式中,直到栈顶元素为“(”时,将栈顶元素“(”弹出(不需要加入后缀表达式),表明这一层括号内的操作处理完毕。 (3)如果遇到的是操作符,则将该操作符和操作符栈顶元素比较: 1、当所遇到的操作符的优先级小于或等于栈顶元素的优先级时,则取出栈顶元素放入后缀表式, 并弹出该栈顶元素,反复执行直到栈顶元素的优先级小于当前操作符的优先级; 2、当所遇到的操作符的优先级大于栈顶元素的优先级的时则将它压入栈中。 (4)重复上述步骤直到遇到中缀表达式的结束符标记“#”,弹出栈中的所有元素并放入后缀表达式中,转换结束。 如果有算法方描述的不清楚,敬请网友指出,本人表达能力较差,欢迎提出问题。 C++ 代码描述算法:

相关文档
最新文档