表达式求值实验报告

合集下载

数据结构实验报告表达式求值

数据结构实验报告表达式求值

数据结构实验报告题目:编制一个表达式求值的程序。

一.需求分析1.本演示程序中,利用堆栈存储结构存储读入的运算符,输入的限定范围是数字(0—9),以及+*/()。

输入字符串限定长度为20,可以根据需要进行改变。

如果遇到不是以上范围或者连续输入两个运算符,如:++,则会提示输入错误,请重新输入。

输出的结果是转换后的后序表达式,以及float型数字,不会含有非法字符。

2.演示程序采用的是文件输入,只需要在源代码中输入要输入的文件的地址,然后就可以在文本文件中进行输入,运行过程中会自动读取,输出文本输入的表达式,及运算结果。

3.程序执行的命令包括:1)构造字符优先级比较表,比较优先关系2)文件输入3)构造堆栈,运算符入栈4)堆栈输出,变为后序表达式,并计算5)输出结果,结束4.测试数据文件地址:C:\\Users\\lenovo\\Desktop\\4.txt1) 输入:(35+20/2)*2-4/2+12正确输出结果是:100.00002)输入:(35+20/2)*2-/2+12结果是:error input3) 输入:a+ar/3=135结果是:error input二.概要设计为实现以上程序功能,需运用堆栈用于存储运算符,因此需要定义抽象数据类型。

1.堆栈的抽象数据类型定义为:ADT stack{数据对象:D={ai|ai∈正整数,i=0,1,2,3,…n,及{+-*/()}}数据关系:R1={<ai-1,a1>|ai-1,ai∈D}基本操作:Init stack(&s)操作结果:构造一个空的堆栈sPush stack(&s, e)初始条件:存在堆栈s操作结果:元素e压入堆栈s,top+1Pop (&s,e)初始条件:栈s已经存在且非空操作结果:删除栈顶元素e,输出其值,top-12.程序包含三个模块:1)运算符优先关系模块2)主程序模块;Int main(void){初始化;Do{接受命令;处理命令;}while(“命令”=”退出”);}3)堆栈模块三.详细设计1.程序源代码解释为:float Result(int c,float r[],int top){ //定义输出结果int j;float temp;switch(c){ //以下是四种基本运算的计算定义,运算完成后直接将top-1值赋予topcase 42:r[top-1]=r[top-1]*r[top];top=top-1;break; //乘法case 43:r[top-1]=r[top-1]+r[top];top=top-1;break;///加法case 45:r[top-1]=r[top-1]-r[top];top=top-1;break;//减法case 47:r[top-1]=r[top-1]/r[top];top=top-1;break;// 除法case 94:for(j=1,temp=r[top-1];j<r[top];j++) //平方或者几次方的运算temp=r[top-1]*temp; //循环相乘r[top-1]=temp;top=top-1;break;}return(r[top]);}if(temp1!=1){while(top>=1){ //栈不空的时候,栈中元素赋给houzhi,并计数biaozhi[b++]=i;houzhi[i]=duizhan[top-1];top=top-1;i=i+1;}max=i; //从0到i循环输出后序表达式for(i=0,b=0;i<max;i++){if(i!=biaozhi[b])printf("%d ",houzhi[i]) ; //输出后序表达式中的数字else {printf("%c ",houzhi[i]); //输出后序表达式中的运算符b=b+1;}}top=-1;for(i=0,b=0;i<max;i++){ //从0到maxif(i!=biaozhi[b]){top=top+1;result[top]=houzhi[i]; //将后值赋予result,调用result函数,进行Result运算}else {Result(houzhi[i],result,top); //运算结束,输出栈顶值,既是运算结果top--;b=b+1;}}printf("\n\nThe result is %f ",Result(houzhi[i],result,top)); //输出并打印结果}}getch();return 0;///返回0}2.程序的模块调用:主程序↓文件打开读入字符↓输入字符有效及优先级的判断↓运算模块↓输出结果四.调试分析1.本次作业的核心就是利用堆栈将中序表达式改成后序表达式,然后进行表达式的求值。

《程序设计方法学》实验报告-算术表达式求值

《程序设计方法学》实验报告-算术表达式求值

X X X X X大学《程序设计方法学》实验报告实验一:算术表达式求值学院:X X X专业:计算机科学与技术姓名:X X X学号:XXXXX2010年11 月18 日目录1.前言 (1)2.概要设计 (1)2.1 数据结构设计 (1)2.2 算法设计 (1)2.3 ADT描述 (2)2.4 功能模块分析 (3)3.详细设计 (3)3.1 数据存储结构设计 (3)3.2主要算法流程图(或算法伪代码) (4)4.测试结果 (7)5.参考文献 (8)附录--程序源代码 (8)1.前言在计算机中,算术表达式由常量、变量、运算符和括号组成。

由于不同的运算符具有不同的优先级,又要考虑括号,因此,算术表达式的求值不可能严格地从左到右进行。

因而在程序设计时,借助栈实现。

算法输入:一个算术表达式,由常量、变量、运算符和括号组成(以字符串形式输入)。

为简化,规定操作数只能为正整数,操作符为+、-*、/,用#表示结束。

算法输出:表达式运算结果。

算法要点:设置运算符栈和运算数栈辅助分析算符优先关系。

在读入表达式的字符序列的同时,完成运算符和运算数的识别处理,以及相应运算。

2.概要设计2.1 数据结构设计任何一个表达式都是由操作符,运算符和界限符组成的。

我们分别用顺序栈来寄存表达式的操作数和运算符。

栈是限定于紧仅在表尾进行插入或删除操作的线性表。

顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素,同时附设指针top指示栈顶元素在顺序栈中的位置,base为栈底指针,在顺序栈中,它始终指向栈底,即top=base可作为栈空的标记,每当插入新的栈顶元素时,指针top增1,删除栈顶元素时,指针top减1。

2.2 算法设计为了实现算符优先算法。

可以使用两个工作栈。

一个称为OPTR,用以寄存运算符,另一个称做OPND,用以寄存操作数或运算结果。

1.首先置操作数栈为空栈,表达式起始符”#”为运算符栈的栈底元素;2.依次读入表达式,若是操作符即进OPND栈,若是运算符则和OPTR栈的栈顶运算符比较优先权后作相应的操作,直至整个表达式求值完毕(即OPTR栈的栈顶元素和当前读入的字符均为”#”)。

数据结构表达式求值实验报告

数据结构表达式求值实验报告

实验报告课程名:数据结构(C语言版)实验名:表达式求值姓名:班级:学号:时间:2014.10.25一实验目的与要求1. 了解栈的应用2. 利用栈进行算术表达式求值二实验内容1.以字符串的形式给出一个算术表达式, 计算出该算术表达式的值。

2.表达式中可能出现”+”, ”−”, ”∗”, ”/”, ”(”, ”)”。

三实验结果与分析分析:r:读入字符t:栈顶字符r( ) # 低优先运算符高优先运算符( 入栈出栈错误入栈入栈) 错误错误错误错误错误t # 入栈错误结束入栈入栈低优先运算符入栈出栈+运算出栈+计算出栈+计算入栈高优先运算符入栈出栈+运算出栈+计算出栈+计算出栈+计算1, 入栈2, 错误3, 出栈4, 出栈+计算5, 结束( ) # 低优先运算符高优先运算符( 1 3 2 1 1) 2 2 2 2 2# 1 2 5 1 1低优先运算符 1 4 4 4 1高优先运算符 1 4 4 4 4此实验可用两个栈和数组来实现,一个操作栈,一个数字栈,两个栈的字符进行优先权比较可得到5种结果。

首先置操作栈为空栈,表达式起始符“#”作为数字栈的栈底元素,依次读入表达式的每个字符,若是操作字符进操作栈,若是数字进数字栈,操作栈和数字栈的栈顶元素比较优先权后进行相应操作,直至结束,最后输出值即可。

实验程序:#include<stdio.h>#include<stdlib.h>#include<string.h>int change(char c)//字符转换{int j=-1;switch(c){case '(':j=0;break;case ')':j=1;break;case '#':j=2;break;case '+':j=3;break;case '-':j=3;break;case '*':j=4;break;case '/':j=4;break;}return(j);}int compu(int x,int y,char c)//数字计算转换{int j=-1;switch(c){case '+':j=x+y;break;case '-':j=x-y;break;case '*':j=x*y;break;case '/':j=x/y;break;}return(j);}void get(char a[],int num_op,int method[5][5]){int a_length=strlen(a)+1;//表达式的长度int p=0,num_p=0,op_p=0;int *num_s=(int *)malloc((a_length)*sizeof(int));// char *op_s=(char *)malloc((a_length)*sizeof(int));// op_s[op_p]='#';op_p++;//进字符栈int k=-1;//输出结果判断int ox,oy;while(1){char c=a[p];//将表达式中的字符一个一个赋值给cif(c>='0'&&c<='9')//判断是不是数字{num_s[num_p]=c-48;//将Ascll码转换成对应数字num_p++;//进数字栈p++;//代表表达式的位置开始为0指向第一位}else{int t=method[change(op_s[op_p-1])][change(c)];//将5种操作的一种传给tswitch(t){case 1:op_s[op_p]=c;op_p++;p++;break;case 2:k=0;break;case 3:op_p--;p++;break;case 4:ox=num_s[num_p-2];oy=num_s[num_p-1];num_p=num_p-2;num_s[num_p]=compu(ox,oy,op_s[op_p-1]);//将计算的值存入num_s[]num_p++;//入数字栈op_p--;break;case 5:k=1;break;}}if(k>=0)//跳出循环{break;}}switch(k)//0错误,1输出结果{case 0:printf("表达式错误!");break;case 1:printf("%s=%d\n",a,num_s[num_p-1]);break;}}int main(int argc,char *argv[]){ char a[20];puts("请输入个位数的表达式:");gets(a);int num_op=5;//表示操作的种数int method[5][5]={{1,3,2,1,1},{2,2,2,2,2},{1,2,5,1,1},{1,4,4,4,1},{1,4,4,4,4}};//1表示入栈,2表示错误,//3表示出栈,4表示出栈+计算,//5表示结束get(a,num_op,method);return 0;}图1.表达式求值运行结果。

数据结构实验报告 表达式求值

数据结构实验报告 表达式求值

(一) 需求分析1、输入的形式和输入值的范围:根据题目要求与提示,先选择你要使用的表达式形式(中缀用1,后缀用0),在输入一个中缀表达式,输入数的范围为int型,此时,程序将计算出表达式的结果。

2、输出的形式:当按照程序要求选择了1或0之后,再输入表达式;如果选择的是1,则程序将自动运算出表达式结果;如果之前选择的是0,则程序将现将中缀表达式转化为后缀表达式并计算出结果。

3、程序所能达到的功能:本程序能计算出含+、-、*、/、(、)等运算符的简单运算。

4、测试数据:输入一个表达式,如果你之前选择的是“中缀表达式”,那么输入5*(4-2)#,那么输出结果是10;如果之前选择的是“后缀表达式”,那么输入5*(4-2)#,那么他将先转换成后缀表达式5 4 2 - * #,再输出结果10。

如果输入表达式没有结束标示符#,如5*(4-2),那将不会输出任何结果,或出现错误结果。

(二) 概要设计为了实现上述操作,应以栈为存储结构。

1.基本操作:(1). int GetTop(SqStack *s)初始条件:栈存在;操作结果:若栈为空,则返回s的栈顶元素;否则返回ERROR。

(2).void Push(SqStack *s,int e)初始条件:栈存在;操作结果:插入e为新的栈顶元素。

(3).int Pop(SqStack *s)初始条件:栈存在;操作结果:若栈不空,则删除之,并返回其值;否则返回REEOR。

(4).void InitStack(SqStack *s)初始条件:栈存在;操作结果:置栈为空。

(5).int Empty(SqStack *s)初始条件:栈存在;操作结果:判定s是否为空栈。

(6).int Operate(int a,char theta, int b)初始条件:操作数a和b存在,且theta是+、-、*、/四则运算;操作结果:返回a与b间theta运算的结果。

(7).int In(char s,char* TestOp)初始条件:s为待判断字符,TestOp为已知的算符集合;操作结果:s为算符集合中的元素则返回1,否则返回0.(8).int ReturnOpOrd(char op,char* TestOp)初始条件:op为待确定运算符,TestOp为已知的算符集合;操作结果:确定运算符类型。

数据结构表达式求值实验报告

数据结构表达式求值实验报告

数据结构表达式求值实验报告数据结构表达式求值实验报告第一章引言数据结构是计算机科学中重要的基础知识之一,它研究的是数据在计算机中的存储和组织方式,以及基于这些方式进行操作和运算的算法。

表达式求值是数据结构中一个重要的应用场景,它涉及到从一个给定的表达式中计算出最终结果的过程。

本实验旨在通过实际编程实践,掌握表达式求值的算法和数据结构的应用。

第二章实验目的1.理解表达式的概念。

2.熟悉常见表达式求值算法。

3.掌握栈的基本操作。

4.实现一个表达式求值的程序。

第三章实验内容1.表达式的定义:________表达式是由运算符和运算数组成的字符串,它代表了一种计算规则。

2.表达式的分类:________根据运算符的位置和计算顺序,表达式可以分为前缀表达式、中缀表达式和后缀表达式。

3.表达式求值的算法:________1. 前缀表达式求值算法:________1) 创建一个空栈。

2) 从右往左遍历前缀表达式。

3) 如果当前字符是运算符,则将栈顶的两个元素出栈,进行相应的运算,将结果入栈。

4) 如果当前字符是运算数,则将其转化为整数形式,并入栈。

5) 最终栈内只剩下一个元素,即为表达式的求值结果。

2. 中缀表达式求值算法:________1) 将中缀表达式转化为后缀表达式。

2) 创建一个空栈。

3) 从左往右遍历后缀表达式。

4) 如果当前字符是运算符,则将栈顶的两个元素出栈,进行相应的运算,将结果入栈。

5) 如果当前字符是运算数,则将其转化为整数形式,并入栈。

6) 最终栈内只剩下一个元素,即为表达式的求值结果。

3. 后缀表达式求值算法:________1) 创建一个空栈。

2) 从左往右遍历后缀表达式。

3) 如果当前字符是运算符,则将栈顶的两个元素出栈,进行相应的运算,将结果入栈。

4) 如果当前字符是运算数,则将其转化为整数形式,并入栈。

5) 最终栈内只剩下一个元素,即为表达式的求值结果。

4.实验代码实现:________根据算法描述,使用编程语言实现一个表达式求值的程序。

数据结构表达式求值(中缀)实验报告

数据结构表达式求值(中缀)实验报告

数据结构表达式求值(中缀)实验报告题目名称表达式求值学号姓名指导教师日期一1. 问题描述:在计算机中,算术表达式由常量、变量、运算符和括号组成。

由于不同的运算符具有不同的优先级,又要考虑括号,因此,算术表达式的求值不可能严格地从左到右进行,在程序设计时,借助栈实现。

2. 表达式求值这个程序,主要利用栈和数组,把运算的先后步骤进行分析并实现简单的运算,以字符列的形式从终端输入语法的正确的、不含变量的整数表达式。

利用已知的算符优先关系,实现对算术四则运算的求值,在求值中运用栈、运算栈、输入字符和主要操作的变化过程。

该程序相当于一个简单的计算机计算程序,只进行简单的加减乘除和带括号的四则运算。

1、基本思想(中缀表达式求值)要把一个表达式翻译成正确求值的一个机器指令序列,或者直接对表达式求值,首先要能够正确解释表达式,要了解算术四则运算的规则即:(1)先乘除后加减;(2)从左到右计算;(3)先括号内,后括号外。

下表定义的运算符之间的关系:b + - * / () # a+ > > < < < > > _ > > < < < > > * > > > > < > > / > > > > < > > ( < < < < < = ) > > > > > > # < < < < < =为了实现运算符有限算法,在程序中使用了两个工作栈。

分别是:运算符栈OPTR,操作数栈OPND.基本思想:(1)首先置操作数栈为空栈,表达式起始符“#”为运算符栈的栈底元素;(2)依次读入表达式中每个字符,若是操作数则进OPND栈,若是运算符则和OPTR栈得栈顶运算符比较优先级后作相应操作。

数据结构表达式求值完整篇(含实验报告)

数据结构表达式求值完整篇(含实验报告)
voidOPND_Pop(Sqstack_OPND
&s,SElemType_OPND&e); //出栈
/*
#i nclude "common .h"
#include "Sqstack.h"
#in clude "other.h"
//
void OPTR_I ni tStack(Sqstack_OPTR &s)
3前面的都听简单的,就是 小数编写这块想了很久,
定义了low做判定符号的标志。如果在运算符后输入负号则low=-1(将p入栈时入栈
的是p*low),继续输入ch
总结:
我觉得写的好的地方在于定义了flag,low分别作为小数入栈和负号与减号区别的条
件。第一次写这么长的代码,还有就是将输入的字符再转到小数这段代码可以留着很有 用。开始考虑的大整数想麻烦了,直接用double难度降低了很多
//取操作数的栈顶元素
voidOPTR_Push(Sqstack_OPTR
&s,SElemType_OPTR e);//入栈
voidOPND_Push(Sqstack_OPND
&s,SElemType_OPND e); //入栈
voidOPTR_Pop(Sqstack_OPTR
&s,SEIemType_OPTR&e); //出栈
//栈基本操作的函数声明
void OPTR_lnitStack(Sqstack_OPTR &s);
//运算符栈初始化
void OPBiblioteka D_InitStack(Sqstack_OPND &s);
//操作数栈初始化

数据结构表达式求值实验报告-无删减范文

数据结构表达式求值实验报告-无删减范文

数据结构表达式求值实验报告数据结构表达式求值实验报告1. 引言表达式求值是计算机科学中的一个重要问题,也是数据结构的一个经典应用。

通过将中缀表达式转换为后缀表达式,并利用栈这一数据结构,可以实现对表达式的有效求值。

本实验旨在探究数据结构在表达式求值中的应用。

2. 实验内容本实验中,我们将实现一个表达式求值的程序。

具体步骤如下:1. 将中缀表达式转换为后缀表达式。

2. 使用栈来求解后缀表达式。

3. 算法原理3.1 中缀表达式转后缀表达式中缀表达式是我们常见的数学表达式,如 2 + 3 4。

而后缀表达式是将操作符放在操作数后面的表达式,上述中缀表达式的后缀表达式为 2 3 4 +。

中缀表达式到后缀表达式的转换可以通过以下步骤完成:1. 初始化一个栈和一个输出队列。

2. 从左到右遍历中缀表达式的每个字符。

3. 如果当前字符是数字,将其加入输出队列。

4. 如果当前字符是左括号,将其压入栈。

5. 如果当前字符是右括号,将栈中的操作符依次弹出并加入输出队列,直到遇到左括号为止。

6. 如果当前字符是操作符,将其与栈顶操作符进行比较:1. 如果栈为空,或者栈顶操作符为左括号,直接将当前操作符压入栈。

2. 否则,比较当前操作符与栈顶操作符的优先级,如果当前操作符的优先级较低,将栈顶操作符弹出并加入输出队列,然后将当前操作符压入栈。

3. 如果当前操作符的优先级大于等于栈顶操作符的优先级,则直接将当前操作符压入栈。

7. 遍历完中缀表达式后,将栈中的操作符依次弹出并加入输出队列。

3.2 后缀表达式求值通过将中缀表达式转换为后缀表达式,我们可以利用栈来对后缀表达式进行求值。

具体求值操作如下:1. 初始化一个栈。

2. 从左到右遍历后缀表达式的每个字符。

3. 如果当前字符是数字,将其加入栈。

4. 如果当前字符是操作符,从栈中弹出两个数字,进行相应的运算,然后将结果加入栈。

5. 遍历完后缀表达式后,栈中的元素即为最终的结果。

4. 实验结果我们用中缀表达式\。

数据结构表达式求值实验报告

数据结构表达式求值实验报告

数据结构表达式求值实验报告数据结构表达式求值实验报告⒈引言本实验旨在研究和实现数据结构中表达式求值的算法。

表达式求值是计算机科学中常见的问题,对于计算机程序的正确性和性能具有重要影响。

本报告将详细介绍实验设计、实验步骤、实验结果及分析,并对实验过程中遇到的问题进行讨论。

⒉实验设计⑴实验目的本实验的目的是实现一个可以对常见的算术表达式进行求值的算法,包括支持基本的加减乘除运算符和括号。

⑵实验环境●操作系统:Windows 10●开发语言:C++●开发工具:Visual Studio 2019⑶数据结构设计为了实现表达式求值的算法,我们需要设计适当的数据结构来存储和处理表达式。

本实验中,我们选择使用栈来实现表达式求值。

●表达式栈:用于存储操作数和运算符。

●运算符栈:用于存储运算符。

⑷算法设计表达式求值的算法可以分为以下几个步骤:●遍历表达式,逐个处理操作数和运算符:●如果是操作数,入表达式栈。

●如果是运算符,与运算符栈栈顶元素进行比较,根据优先级决定如何处理。

●当表达式遍历完成后,依次处理剩余的运算符。

●最终表达式栈中的元素即为求值结果。

⒊实验步骤⑴数据结构实现根据设计,我们首先实现表达式栈和运算符栈的数据结构,包括入栈、出栈等操作。

⑵表达式输入与预处理用户输入待求值的表达式,进行预处理,去除空格、验证表达式的合法性等。

⑶表达式求值算法实现根据前述的算法设计,实现表达式求值的算法,利用表达式栈和运算符栈来处理表达式。

⑷测试与结果分析对于不同的测试用例,进行表达式求值的测试,并分析结果的正确性和性能。

⒋实验结果与分析经过实验测试,我们得到了表达式求值的结果。

结果显示,我们的算法能够正确地求得表达式的值,而且性能良好。

⒌讨论与总结在实验过程中,我们遇到了一些问题,并进行了讨论和解决。

通过这个实验,我们更加深入地理解了表达式求值的算法,并对数据结构的应用有了更清晰的认识。

附件:无法律名词及注释:●无。

实验报告二--表达式求值

实验报告二--表达式求值

实验报告二表达式求值一、问题描述1.实验题目:表达式求值2.基本要求:输入一个算术表达式,输出其值。

3.测试数据:表达式为:1.5+(2-3)*2# (#表示结束)运行结果应为:-0.500000二、需求分析1. 本程序用来求任意一个由浮点型数据和加减乘除四则运算构成的简单算术表达式的值。

2. 用户根据程序运行后的提示信息输入算术表达式,运算符仅限+-*/,操作数仅限浮点数,表达式以#结尾表示结束。

3. 用户输入完毕后,程序自动输出运算结果。

三、设计核心算法:采用算符优先算法,使用两个工作栈,一个称为OPTR,用来存放运算符;另一个称为OPND,用来寄放操作数或运算结果。

算法的基本思想是:(1)首先置操作数为空栈,表达式起始符"#"为运算符栈的栈底元素;(2)依次读入表达式中的每个字符,若是操作数则进OPND栈,若是运算符则和OPTR栈的栈顶元素比较优先权后作相应操作,直至整个表达式求值完毕(输入为"#").四、测试结果五、附录//表达式求值#include <stdio.h>#include <stdlib.h>#include <string.h>#define error 0#define ok 1#define overflow -1#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OPSETSIZE 7char OPSET[OPSETSIZE]={'+','-','*','/','(',')','#'}; unsigned char Prior[7][7] = { // 算符间的优先关系'>','>','<','<','<','>','>','>','>','<','<','<','>','>','>','>','>','>','<','>','>','>','>','>','>','<','>','>','<','<','<','<','<','=',' ','>','>','>','>',' ','>','>','<','<','<','<','<',' ','='};typedef int Status;template <typename T>struct SqStack{T *top;T *base;int stacksize;};//顺序栈结构模板template <typename T1,typename T2>Status InitStack(T1 &S){S.base=(T2 *)malloc(STACK_INIT_SIZE*sizeof(T2));if(!S.base) exit (overflow);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return ok;}//初始化栈函数模板template <typename T1,typename T2>Status Push(T1 &S,T2 e){if(S.top-S.base>=S.stacksize){S.base=(T2 *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(T2));if(!S.base) exit (overflow);S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return ok;}//入栈函数模板template <typename T1,typename T2>Status Pop(T1 &S,T2 &e){if(S.top==S.base) return error;e=*--S.top;return ok;}//出栈函数模板template <typename T1,typename T2>T2 GetTop(T1 S){if(S.top==S.base)return error;elsereturn *(S.top-1);}//获取栈顶元素模板Status In(char Test,char* TestOp) {bool Find=false;for (int i=0; i< OPSETSIZE; i++) {if (Test == TestOp[i]) Find= true;}return Find;}//判断是否为运算符float Operate(float a,unsigned char theta, float b) {switch(theta) {case '+': return a+b;case '-': return a-b;case '*': return a*b;case '/': return a/b;default : return 0;}}//运算int ReturnOpOrd(char op,char* TestOp) {int i;for(i=0; i< OPSETSIZE; i++) {if (op == TestOp[i]) return i;}return 0;}char precede(char Aop, char Bop) {return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];}//ReturnOpOrd和precede组合,判断运算符优先级float EvaluateExpression() {// 算术表达式求值的算符优先算法。

数据结构实验二——算术表达式求值实验报告

数据结构实验二——算术表达式求值实验报告

数据结构实验二——算术表达式求值实验报告算术表达式求值实验报告一、引言算术表达式求值是计算机科学中一个重要的基础问题,它涉及到了数据结构和算法的应用。

本实验旨在通过实现一个算术表达式求值的程序,加深对数据结构中栈的理解和应用,并掌握算术表达式的求值过程。

二、实验目的1. 理解算术表达式的基本概念和求值过程;2. 掌握栈的基本操作和应用;3. 实现一个能够正确求解算术表达式的程序;4. 进一步熟悉编程语言的使用。

三、实验内容1. 设计并实现一个栈的数据结构;2. 实现算术表达式求值的算法;3. 编写测试用例,验证程序的正确性;4. 进行性能测试,分析算法的时间复杂度。

四、实验方法与步骤1. 设计栈的数据结构在本实验中,我们选择使用数组来实现栈的数据结构。

栈的基本操作包括入栈(push)、出栈(pop)、判断栈空(isEmpty)和获取栈顶元素(top)等。

2. 算术表达式求值算法算术表达式求值的一种常用算法是通过后缀表达式进行求值。

具体步骤如下: - 将中缀表达式转换为后缀表达式;- 通过栈来求解后缀表达式;- 返回最终的计算结果。

3. 编写测试用例编写一系列测试用例,包括不同类型的算术表达式,以验证程序的正确性。

例如:- 简单的四则运算表达式:2 + 3 * 4 - 5;- 包含括号的表达式:(2 + 3) * (4 - 5);- 包含多位数的表达式:12 + 34 * 56;- 包含浮点数的表达式:3.14 + 2.71828。

4. 性能测试和时间复杂度分析针对不同规模的输入数据,进行性能测试,记录程序的运行时间。

同时,分析算法的时间复杂度,验证算法的效率。

五、实验结果与分析我们设计并实现了一个栈的数据结构,并成功地完成了算术表达式求值的程序。

通过对一系列测试用例的验证,我们发现程序能够正确地求解各种类型的算术表达式,并返回正确的计算结果。

在性能测试中,我们对不同规模的输入数据进行了测试,并记录了程序的运行时间。

算术表达式求值实验报告

算术表达式求值实验报告

算术表达式求值实验报告1. 背景算术表达式求值是计算机科学中的基本问题之一,涉及到对数学表达式的解析和计算。

在计算机编程中,经常需要对用户输入的数学表达式进行求值,以得到正确的计算结果。

因此,研究如何高效地求解算术表达式是非常重要的。

在本次实验中,我们将探索不同方法来求解算术表达式,并比较它们的性能和准确性。

我们将使用Python语言作为实现工具,并通过编写代码来实现不同方法。

2. 分析2.1 表达式解析在进行表达式求值之前,我们首先需要对输入的数学表达式进行解析。

解析过程主要包括以下几个步骤:1.去除空格:将输入的字符串中的空格字符去除。

2.分词:将字符串按照运算符和操作数进行分割,得到一个由标记组成的列表。

3.构建语法树:根据分词结果构建一个语法树,用于表示数学表达式的结构。

4.求值:通过遍历语法树并执行相应操作,最终得到表达式的值。

2.2 求值方法在本次实验中,我们将尝试以下两种不同的求值方法:1.递归求值:通过递归地遍历语法树来求解表达式。

递归求值的优点是简单易懂,但可能存在性能问题。

2.栈求值:使用栈数据结构来辅助求解表达式。

栈可以有效地处理运算符的优先级和括号的匹配问题。

2.3 性能评估为了评估不同方法的性能,我们将使用一组测试用例来对其进行比较。

测试用例包括不同长度和复杂度的数学表达式,以及各种运算符和括号的组合。

我们将使用Python内置的time模块来测量每种方法的执行时间,并比较它们之间的差异。

此外,我们还将检查每种方法是否能正确地计算出表达式的结果。

3. 实验结果3.1 表达式解析在实现表达式解析过程时,我们首先去除输入字符串中的空格,并将其转换为一个字符列表。

然后,我们使用递归下降法来构建语法树。

具体而言,我们定义了以下几个函数:1.parse_expression(tokens):该函数接受一个标记列表作为参数,并返回一个表示整个表达式的语法树。

2.parse_term(tokens):该函数接受一个标记列表作为参数,并返回一个表示项的语法树。

表达式求值数据结构实训报告

表达式求值数据结构实训报告

数据结构实训总结报告题目:表达式求值学生姓名:学生学号:专业班级:指导老师:目录1.课题分析 .....................................................................1.1需求分析..............................................................1. 2设计要求............................................................2.总体设计.......................................................................2.1主程序的流程.....................................................3.详细设计(步骤及代码实现) ...................................3. 1判断运算符优先级..............................................3. 2中缀表达式转后缀表达式..................................3. 3后缀表达式求值.................................................. 4.测试结果 .................................................................... 5.心得体会 .................................................................... 6.参考文献 ....................................................................1.课题分析1.1需求分析(1)栈“后进先出”的特点。

数据结构表达式求值实验报告

数据结构表达式求值实验报告

实验二表达式求值
实验内容:
用算符优先法设计一个具有加、减、乘、除四功能的计算程序。

实验目的与要求:
掌握栈的数据结构和基本操作。

实验原理:
1.表达式是由操作数,运算符和界限符组成。

2.实现算符优先算法,实用两个工作栈。

一个叫OPTR,用以寄存运算符;一个叫OPND,用以寄存操作数或运算结果。

3.算法的基本思路:
(1)首先置操作数栈为空栈,表达式起始符#作为运算符栈的栈底元素;
(2) 依次读入表达式中的每个字符,通过运算符判断函数In()使操作数进OPND 栈;
(3)通过函数Precede()将运算符与OPTR栈的栈底运算符比较出优先权,若栈顶元素优先权低则输入下个操作数到OPND,若两优先权相等,脱号并接受下一个字符,若栈顶元素优先高,退栈并将运算结果(通过函数Operate()运算)入栈。

循环上述操作直到表达式求值结束。

(4)返回运算结果。

4.所用的函数及作用:
InitStack():构造一个空栈
Push():插入元素进栈
GetTop():返回栈顶元素
Precede():运算符优先权进行判断
Pop():元素出栈
Operate():运算操作数
5. 测试结果与分析
上述程序在Visual C++ 6.0环境下加以实现。

经过多次测试,程序运行正确。

运行结果。

如图所示:
6. 收获与体会
通过这次课程设计:
1.我又进一步巩固了C语言的基础,尤其是栈。

2.算法中需要建很多的函数,队提高了自己的编程能力有帮助,
3.程序不够简洁,还有待改进,功能还有待更完善。

数据结构实验报告——四则运算表达式求值

数据结构实验报告——四则运算表达式求值

数据结构实验报告——四则运算表达式求值实验五四则运算表达式求值一.问题描述:四则运算表达式求值,将四则运算表达式用中缀表达式,然后转换为后缀表达式,并计算结果。

二.基本要求:使用二叉树来实现。

三.实现提示:利用二叉树后序遍历来实现表达式的转换,同时可以使用实验二的结果来求解后缀表达式的值。

输入输出格式:输入:在字符界面上输入一个中缀表达式,回车表示结束。

输出:如果该中缀表达式正确,那么在字符界面上输出其后缀表达式,其中后缀表达式中两相邻操作数之间利用空格隔开;如果不正确,在字符界面上输出表达式错误提示。

测试实例:输入:21+23* (12-6 )输出:21 23 12 6 -*+四.设计概要用二叉树表示表达式:若表达式为数或简单变量,则相应二叉树中仅有一个根结点,其数据域存放该表达式信息若表达式= (第一操作数)(运算符)(第二操作数),则相应的二叉树中以左子树表示第一操作数,右子树表示第二操作数,根结点的数据域存放运算符(若为一元算符,则左子树空)。

操作数本身又为表达式.后缀遍历二叉树码实现和静态检查上机调试及测试数据的调试五.源程序:#include#include#include#include#include#include#define STACK_INIT_SIZE 100#define DATA_SIZE 10#define STACKINCREMENT 10#define OK 1#define TRUE 1#define FALSE 0#define ERROR 0#define OVERFLOW -2using namespace std;typedef float SElemtype;typedef int Status;typedef char * TElemType;typedef struct BiTNode {TElemType data;int len; //data字符串中字符的个数struct BiTNode * lchild, * rchild;}BiTNode, *BiTree;typedef struct{SElemtype *base;SElemtype *top;int stacksize;} SqStack;Status IsDigital(char ch)if(ch>='0'&&ch<='9'){return 1; //是数字字母}return 0; //不是数字字母}int CrtNode(stack &PTR, char *c){BiTNode * T;int i=0;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));while(IsDigital(c[i])){T->data [i] = c[i];i++;}T->len = i;T->lchild = T->rchild = NULL;PTR.push (T);return i;}void CrtSubTree(stack &PTR, char c){BiTNode * T;T = (BiTNode *)malloc(sizeof(BiTNode));T->data = (char *)malloc(DATA_SIZE*sizeof(char));T->data [0] = c;T->len = 1;T->rchild = PTR.top(); //先右子树,否则运算次序反了PTR.pop ();T->lchild = PTR.top();PTR.pop ();PTR.push (T);}char symbol[5][5]={{'>', '>', '<', '<', '>'}, //符号优先级{'>', '>', '<', '<', '>'},{'>', '>', '>', '>', '>'},{'>', '>', '>', '>', '>'},{'<', '<', '<', '<', '='}};int sym2num(char s) //返回符号对应优先级矩阵位置{switch(s){case '+': return 0; break;case '-': return 1; break;case '*': return 2; break;case '/': return 3; break;case '#': return 4; break;}}char Precede(char a, char b) //返回符号优先级{return(symbol[sym2num(a)][sym2num(b)]);void CrtExptree(BiTree &T, char exp[]){//根据字符串exp的内容构建表达式树Tstack PTR;//存放表达式树中的节点指针stack OPTR;//存放操作符char op;int i=0;OPTR.push ('#');op = OPTR.top();while( !((exp[i]=='#') && (OPTR.top()=='#')) ) //与{ if (IsDigital(exp[i])){//建立叶子节点并入栈PTRi+=CrtNode(PTR, &exp[i]);}else if (exp[i] == ' ')i++;else{switch (exp[i]){case '(': {OPTR.push (exp[i]);i++;break;}case ')': {op = OPTR.top (); OPTR.pop ();while(op!='('){CrtSubTree(PTR, op);op = OPTR.top (); OPTR.pop ();}//end whilei++;break;}default: //exp[i]是+ - * /while(! OPTR.empty ()){op = OPTR.top ();if (Precede(op, exp[i])=='>'){CrtSubTree(PTR, op);OPTR.pop ();}if(exp[i]!='#'){OPTR.push (exp[i]);i++;}break;}}//end switch}//end else}//end whileT = PTR.top();PTR.pop ();}void PostOrderTraverse(BiTree &T, char * exp ,int &count){//后序遍历表达式树T,获取树中每个结点的数据值生成逆波兰表达式exp //T是表达式树的根节点;字符串exp保存逆波兰表达式;count保存exp中字符的个数//后序遍历中,处理根结点时,依据T->len的值,把T->data中的字符依次添加到当前exp字符串的尾端//添加完T->data后,再添加一个空格字符,同时更新count计数器的值。

算术表达式求值数据结构实验报告

算术表达式求值数据结构实验报告

算法的正确性和效率分析
正确性
所有实现的数据结构都正确地实现了算术表达式求值的功能,没有出现计算错 误的情况。
效率
在处理大量数据时,使用堆栈(Stack)和队列(Queue)的数据结构表现最 佳。堆栈在处理后缀表达式时效率最高,而队列在处理中缀表达式时效率最高 。
数据结构优化的效果评估
使用哈希表(Hash Table)
展望未来,希望能够进一步研究算术 表达式求值算法的优化和改进,提高 计算效率和精度。
THANKS
感谢观看
05
列表(List)
数组(Array) 元组(Tuple) 集合(Set)
字典( Dictiona…
由于列表在Python中是动 态数组,其性能在处理大 量数据时相对较差。在算 术表达式求值中,列表的 平均执行时间最长。
使用NumPy库的数组结构 ,其性能在处理大量数据 时优于列表。但在算术表 达式求值中,其性能仍然 不如其他数据结构。
03
了解如何使用栈数据结构实现括号匹配和回退机制 。
掌握数据结构在算术表达式求值中的应用
01 熟悉使用数组、链表等基本数据结构存储和操作 算术表达式。
02 掌握如何使用树形数据结构表示算术表达式,如 二叉树或表达式树。
03 了解动态规划在优化算术表达式求值中的运用。
提高编程能力和解决问题的能力
01
在处理重复元素时,使用哈希表可以显著提高数据结构的效率。在算术表达式求值中,哈希表的使用可以减少重 复计算和查找的时间。
预处理输入数据
对输入的算术表达式进行预处理,如括号消除、指数化等,也可以提高数据结构的效率。预处理可以减少运算的 复杂度和时间。
05
实验总结
本次实验的收获和体会

表达式求值 实验报告

表达式求值 实验报告

表达式求值实验报告表达式求值实验报告一、引言表达式求值是计算机科学中一个重要的概念,它涉及到对数学表达式的计算和求解。

在本次实验中,我们将探讨表达式求值的相关算法和实现方法,并通过编程实现一个简单的表达式求值器。

二、算法原理1. 表达式的表示方法在计算机中,我们通常使用字符串来表示表达式。

例如,一个简单的数学表达式"2 + 3 * 4"可以表示为字符串"2+3*4"。

在实现表达式求值的算法时,我们需要将字符串中的数字和运算符进行分离,以便进行后续的计算。

2. 中缀表达式转后缀表达式为了方便计算,我们通常将中缀表达式转换为后缀表达式。

后缀表达式也称为逆波兰表达式,它的特点是运算符位于操作数的后面。

例如,上述的中缀表达式"2+3*4"可以转换为后缀表达式"234*+"。

转换的方法可以通过使用栈来实现。

3. 后缀表达式求值得到后缀表达式后,我们可以通过扫描表达式并使用栈来求解。

当遇到操作数时,将其压入栈中;当遇到运算符时,从栈中弹出相应数量的操作数进行计算,并将结果压入栈中。

最终,栈中的唯一元素即为表达式的求值结果。

三、实验过程1. 数据结构设计为了实现表达式求值器,我们需要设计相应的数据结构。

在本次实验中,我们选择使用栈来存储操作数和运算符。

2. 中缀表达式转后缀表达式首先,我们需要编写一个函数来将中缀表达式转换为后缀表达式。

该函数的实现可以通过使用栈和遍历字符串来实现。

具体的步骤如下:- 创建一个空栈和一个空字符串用于存储后缀表达式。

- 从左到右遍历中缀表达式的每个字符。

- 如果遇到操作数,直接将其添加到后缀表达式字符串中。

- 如果遇到运算符,将其与栈顶的运算符进行比较:- 如果栈为空或栈顶为左括号"(",则直接将运算符入栈。

- 如果栈顶的运算符优先级低于当前运算符,则将当前运算符入栈。

- 如果栈顶的运算符优先级高于或等于当前运算符,则将栈顶的运算符弹出并添加到后缀表达式字符串中,直到栈顶的运算符优先级低于当前运算符或栈为空。

数据结构表达式求值实验报告

数据结构表达式求值实验报告

数据结构表达式求值实验报告一、实验目的本次实验的主要目的是通过实现表达式求值的程序,深入理解数据结构和算法在解决实际问题中的应用。

具体包括掌握栈这种数据结构的操作和使用,熟悉表达式的转换和计算过程,提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理表达式求值是程序设计中的一个常见问题,通常采用栈这种数据结构来实现。

表达式可以分为中缀表达式、后缀表达式和前缀表达式。

中缀表达式是我们日常使用的表达式形式,如“2 +3 4”,但直接对中缀表达式求值比较复杂。

而后缀表达式(如“2 3 4 +”)和前缀表达式(如“+2 3 4”)求值相对简单。

因此,在实现表达式求值时,通常先将中缀表达式转换为后缀表达式,然后对后缀表达式进行求值。

转换过程中,使用两个栈,一个用于存储操作数,另一个用于存储运算符。

求值过程中,根据后缀表达式的特点,从左到右依次处理操作数和运算符,进行相应的计算。

四、实验步骤1、定义数据结构定义栈类,用于存储操作数和运算符。

定义一个结构体来表示操作数和运算符。

2、中缀表达式转后缀表达式从左到右扫描中缀表达式。

遇到操作数,直接输出。

遇到运算符,根据其优先级与栈顶运算符的优先级进行比较,决定入栈或出栈操作。

3、后缀表达式求值从左到右扫描后缀表达式。

遇到操作数,入栈。

遇到运算符,从栈中取出两个操作数进行计算,将结果入栈。

4、主函数输入中缀表达式。

调用转换函数和求值函数,输出计算结果。

五、实验代码```cppinclude <iostream>include <stack>include <string>//定义操作符的优先级int priority(char op) {if (op =='+'|| op =='')return 1;if (op ==''|| op =='/')return 2;return 0;}//中缀表达式转后缀表达式std::string infixToPostfix(std::string infix) {std::stack<char> opStack;std::string postfix ="";for (char c : infix) {if (isdigit(c)){postfix += c;} else if (c =='('){} else if (c ==')'){while (!opStackempty()&& opStacktop()!='('){postfix += opStacktop();opStackpop();}opStackpop();//弹出'('} else {while (!opStackempty()&& priority(opStacktop())>=priority(c)){postfix += opStacktop();opStackpop();}opStackpush(c);}}while (!opStackempty()){postfix += opStacktop();}return postfix;}//后缀表达式求值int evaluatePostfix(std::string postfix) {std::stack<int> operandStack;for (char c : postfix) {if (isdigit(c)){operandStackpush(c '0');} else {int operand2 = operandStacktop();operandStackpop();int operand1 = operandStacktop();operandStackpop();switch (c) {case '+':operandStackpush(operand1 + operand2);break;case '':operandStackpush(operand1 operand2);break;case '':operandStackpush(operand1 operand2);break;case '/':operandStackpush(operand1 / operand2);break;}}}return operandStacktop();}int main(){std::string infixExpression;std::cout <<"请输入中缀表达式: ";std::cin >> infixExpression;std::string postfixExpression = infixToPostfix(infixExpression);int result = evaluatePostfix(postfixExpression);std::cout <<"表达式的计算结果为: "<< result << std::endl;return 0;}```六、实验结果输入不同的中缀表达式,如“2 +3 4”“( 2 + 3 )4”等,程序能够正确地将其转换为后缀表达式,并计算出结果。

数据结构表达式求值完整篇(含实验报告)

数据结构表达式求值完整篇(含实验报告)
1.栈的定义、初始化、出栈进栈、取栈顶元素等步骤不难就先把结构打好了
2.操作数和运算符分别入不同的栈
char->int 进操作数栈
先考虑了小于10的整数直接进栈,重点是运算符的优先级这块函数的编写
3前面的都听简单的,就是小数编写这块想了很久,
将单个字符转为整数后还要定一个double p;使依次输入的数成一个小数->p.
}
//操作数栈初始化
void OPND_InitStack(Sqstack_OPND &s)
{
s.base=new SElemType_OPND[MAXSIZE];
if(!s.base)
printf("\n操作数栈存储分配失败!\n");
s.top=s.base;
s.stacksize=MAXSIZE;
if(ch != '.' )
{
if ( dimo != '.' )
{
p = p*10 ;
p += (ch-'0');
scanf("%c",&ch);
}
else if ( dimo == '.')
{
p = p+(ch-'0')*q;
q=q*q;;
scanf("%c",&ch#39;.' )
}
//操作数入栈
void OPND_Push(Sqstack_OPND &s,SElemType_OPND e)
{
if(s.top-s.base == s.stacksize)
printf("\n满栈!\n");

数据结构表达式求值实验报告

数据结构表达式求值实验报告

数据结构表达式求值实验报告关键信息项:1、实验目的:____________________________2、实验环境:____________________________3、实验原理:____________________________4、实验步骤:____________________________5、测试用例及结果:____________________________6、实验总结:____________________________11 实验目的本实验的主要目的是通过使用数据结构和算法来实现表达式求值的功能,加深对栈、队列等数据结构的理解和运用,提高编程能力和解决实际问题的能力。

111 具体目标包括掌握中缀表达式转换为后缀表达式的方法。

利用栈结构实现后缀表达式的求值运算。

能够处理表达式中的运算符优先级和括号。

12 实验环境本次实验使用的编程环境为具体编程语言和版本,在操作系统名称操作系统上进行。

121 所需软件和工具编程软件名称:用于编写和调试代码。

测试工具名称:用于对程序进行测试和验证。

13 实验原理表达式求值是程序设计中的一个常见问题。

中缀表达式符合人们的日常书写习惯,但直接求值较为复杂。

将中缀表达式转换为后缀表达式后,求值过程会变得更加简单和直观。

131 中缀转后缀表达式的原理遇到操作数,直接输出。

遇到运算符,将其与栈顶运算符进行优先级比较。

若优先级高于栈顶运算符,则入栈;否则,弹出栈顶运算符并输出,直到当前运算符优先级高于栈顶运算符或栈为空,然后将当前运算符入栈。

遇到左括号,直接入栈。

遇到右括号,弹出栈顶运算符并输出,直到遇到左括号,左括号出栈但不输出。

132 后缀表达式求值的原理从左到右扫描后缀表达式。

遇到操作数,压入栈中。

遇到运算符,从栈中弹出两个操作数,进行相应运算,将结果压入栈中。

扫描结束后,栈顶元素即为表达式的结果。

14 实验步骤141 数据结构设计定义一个栈来存储运算符。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

淮海工学院计算机工程学院课程设计报告设计名称:数据结构课程设计选题名称:表达式求值姓名:学号:专业班级:系(院):计算机工程学院设计时间:设计地点:软件工程实验室、教室指导教师评语:成绩:签名:年月日1.课程设计目的1、训练学生灵活使用所学数据结构知识,独立完成问题分析,结合数据结构理论知识,编写程序求解指定问题。

2.初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力;4.训练用系统的观点和软件开发一般规范进行软件开发,巩固、深化学生的理论知识,提高编程水平,并在此过程中培养他们严谨的科学态度和良好的工作作风。

2.课程设计任务和要求:任务根据教材《数据结构-C语言描述》(耿国华主编)和参考书《数据结构题集(C语言版)》(严蔚敏、吴伟民主编)选择课程设计题目,要求通过设计,在数据结构的逻辑特性和物理表示、数据结构的选择使用、算法的设计及其实现等方面加深对课程基本内容的理解和综合运用。

设计题目从任务书所列选题表中选取,每班每题不得超过2人。

学生自选课题学生原则上可以结合个人爱好自选课题,要求课题有一定的深度和难度,有一定的算法复杂性,能够巩固数据结构课程所学的知识。

学生自选课题需在18周前报课程设计指导教师批准方可生效。

要求:1、在处理每个题目时,要求从分析题目的需求入手,按设计抽象数据类型、构思算法、通过设计实现抽象数据类型、编制上机程序和上机调试等若干步骤完成题目,最终写出完整的分析报告。

前期准备工作完备和否直接影响到后序上机调试工作的效率。

在程序设计阶段应尽量利用已有的标准函数,加大代码的重用率。

2、.设计的题目要求达到一定工作量(300行以上代码),并具有一定的深度和难度。

3、程序设计语言推荐使用C/C++,程序书写规范,源程序需加必要的注释;4、每位同学需提交可独立运行的程序;5 、每位同学需独立提交设计报告书(每人一份),要求编排格式统一、规范、内容充实,不少于10页(代码不算);6、课程设计实践作为培养学生动手能力的一种手段,单独考核。

3.课程设计说明书一 需求分析[问题描述]一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

假设操作数是正整数,运算符只含加减乘除等四种运算符,界限符有左右括号和表达式起始、结束符“#”,如:#(7+15)*(23-28/4)#。

引入表达式起始、结束符是为了方便。

编程利用“算符优先法”求算术表达式的值。

[基本要求](1) 从键盘读入一个合法的算术表达式,输出正确的结果。

(2) 显示输入序列和栈的变化过程。

二 概要设计1、设定“操作数”的栈的抽象数据类型定义: ADT SqStack_f{数据对象:D={i a },+∈∈N i R a i数据关系:R1={<1,-i i a a >|1-i a ,D a i ∈,i=2,…,n}约定n a 端为栈顶,i a 端为栈底。

基本操作:InitStack_f(&S)操作结果:构造一个空栈S 。

GetTop_f(&S,&e) 初始条件:栈S 已存在。

操作结果:用e 返回S 的栈顶元素。

Push_f(&S ,ch)初始条件:栈S 已存在。

操作结果:插入元素ch 为新的栈顶元素。

Pop_f(&S,&e)初始条件:栈S 已存在。

操作结果:删除S 的栈顶元素,并以e 返回其值。

}ADT SqStack_f2、设定“操作符”的栈的抽象数据类型定义:ADT SqStack_c{数据对象:D={i a {}},'^'/'''*'''''+∈-+∈N i a i数据关系:R1={<1,-i i a a >|1-i a ,D a i ∈,i=2,…,n}约定n a 端为栈顶,i a 端为栈底。

基本操作:InitStack_c(&S)操作结果:构造一个空栈S 。

GetTop_c(&S,&e) 初始条件:栈S 已存在。

操作结果:用e返回S的栈顶元素。

Push_c(&S,ch)初始条件:栈S已存在。

操作结果:插入元素ch为新的栈顶元素。

Pop_c(&S,&e)初始条件:栈S已存在。

操作结果:删除S的栈顶元素,并以e返回其值。

}ADT SqStack_c3、本程序包含六个模块1)主程序模块void main( ){初始化;while(命令==“继续”){接受数据;处理数据;接受命令;}}2)栈模块——实现栈抽象数据类型3)判断运算符优先级模块——判断运算符的优先级别4)后缀表达式转换模块——将中缀表达式转换为后缀表达式,方便操作5)无括号表示式求值运算模块——根据后缀表达式求值,并输出中间和最终结果6)运算结果输出模块——以正确形式输出表达式的值三详细设计1、主程序中需要的全程量#define TTACK_INIT_SIZE 100 //初始分配最大空间量#define STACKINCREMENT 10 //(默认)增补空间量2、结点类型、指针类型typedef struct{float *base; //存储实型数据元素的一位数组float *top; //栈顶指针int stacksize; //栈数组容量}SqStack_f; //有序存储实型的顺序表类型typedef struct{char *base; //存储字符数据元素的一位数组char *top; //栈顶指针int stacksize; //栈数组容量}SqStack_c; //有序存储字符型的顺序表类型void InitStack_f(SqStack_f *s)void InitStack_f(SqStack_f *s)//构造一个存储实型(字符型)的空栈,预设空间为100,分配失败就退出void GetTop_f(SqStack_f *s,float *e)void GetTop_c(SqStack_c *s,char *e)//若栈s不空,则以e带值返栈顶元素,否则显示错误“ERROR”,并退出程序void Push_f(SqStack_f *s,float e)void Push_c(SqStack_c *s,char e)//在s的栈顶插入新的栈顶元素e,若栈的当前空间已满,则追加存储空间void Pop_f(SqStack_f *s,float *e)void Pop_c(SqStack_c *s,char *e)//若栈s不空,则删除栈s的栈顶元素,用e带值返回,否则退出程序其中部分操作的伪码算法(由于比较类似,以浮点型的栈为例)void InitStack_f(SqStack_f *s){//构造一个存储实型的空栈,预设空间为100,分配失败就退出s->base=(float *)malloc(TTACK_INIT_SIZE*sizeof(float));if(!s->base)exit(1);s->top=s->base;s->stacksize=TTACK_INIT_SIZE;}void GetTop_f(SqStack_f *s,float *e){//若栈s不空,则以e带值返栈顶元素,否则显示错误“ERROR”,并退出程序if(s->top==s->base){printf("ERROR!\n");exit(1);}*e=*(s->top-1);}void Push_f(SqStack_f *s,float e){//在s的栈顶插入新的栈顶元素e,若栈的当前空间已满,则追加存储空间if(s->top-s->base>=s->stacksize){s->base=(float *)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(float));if(!s->base){printf("OVERFLOW!\n");exit(1);}s->top=s->base+s->stacksize;s->stacksize+=STACKINCREMENT;}*s->top++=e;}void Pop_f(SqStack_f *s,float *e){//若栈s不空,则删除栈s的栈顶元素,用e带值返回,否则退出程序if(s->top==s->base)exit(1);*e=*--s->top;}3、判断运算符优先级的算法:算符间的优先关系如下:+ - * / ( ) # + >= < < < < > >- > >= < < < > >* > > >= > < > >/ > > > >= < > >( < < < < < =) > > > > > ># < < < < < = 伪码算法:int precede(char Top_char,char s1_char){//栈顶的运算符赋给Top_char,新读入的运算符赋给s1_char。

判断它们的优先级//若栈顶运算符优先级高,则返回1,否则返回0int i,pre[2];char op[2];op[0]=Top_char; //栈顶的运算符赋给op[0]op[1]=s1_char; //新读入的运算符赋给op[1]for(i=0;i<2;i++)switch(op[i]){case'(':case')':pre[i]=0;break; //将括号的优先级设为0case'+':case'-':pre[i]=1;break; //将+ - 运算符的优先级设为1case'*':case'/':pre[i]=2;break; //将* / 运算符的优先级设为2case'^':pre[i]=3;break; //将^ 运算符的优先级设为3}if(pre[0]>=pre[1]) //栈顶元素优先级高返回1return 1;elsereturn 0; //否则返回0}4、中缀表达式转换为后缀表达式的算法:算法过程描述:1)首先将左括号“(”压进栈,作为栈底元素;2)从左而右对算数表达式进行扫描,每次读入一个字符s1[i];3)若遇到数字或小数点,则立即写入s2[i],若遇算数运算符,将“”(空格)写入s2[i];4)遇到左括号“(”则压栈;5)若遇算术运算符,如果它们的优先级比栈顶元素高,则直接进栈,否则弹出栈顶元素输出到s2[i],直到新栈顶元素的优先级比它低,然后将它压栈;6)若遇到右括号“)”,则将栈顶元素输出到s2[i],直到栈顶元素为“(”,然后相互抵消;7)当扫描到“#”符号,表明表达式串已全部输入,将栈中的运算符全部输出到s2[i],并删除栈顶元素。

相关文档
最新文档