最新《数据结构》算术表达式求值

合集下载

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

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

竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一:数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院:化学与材料科学学院专业班级:09级材料科学与工程系pb0920603姓学邮名:李维谷号:pb09206285箱:指导教师:贾伯琪实验时间:20XX年10月10日一、需要分析问题描述:表达式计算是实现程序设计语言的基本问题之一,它的实现是栈的应用的一个典型例子。

设计一个程序,演示通过将数学表达式字符串转化为后缀表达式,并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。

问题分析:在计算机中,算术表达式由常量、变量、运算符和括号组成。

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

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

设置运算符栈(字符型)和运算数栈(浮点型)辅助分析算符优先关系。

在读入表达式的字符序列的同时完成运算符和运算数的识别处理,然后进行运算数的数值转换在进行四则运算。

在运算之后输出正确运算结果,输入表达式后演示在求值中运算数栈内的栈顶数据变化过程,最后得到运算结果。

算法规定:输入形式:一个(:数据结构表达式求值实验报告)算术表达式,由常量、变量、运算符和括号组成(以字符串形式输入)。

为使实验更完善,允许操作数为实数,操作符为(、)、.(表示小数点)、+、-、*、/、^(表示乘方),用#表示结束。

输出形式:演示表达式运算的中间结果和整个表达式的最终结果,以浮点型输出。

程序功能:对实数内的加减乘除乘方运算能正确的运算出结果,并能正确对错误输入和无定义的运算报错,能连续测试多组数据。

测试数据:正确输入:12*(3.6/3+4^2-1)#输出结果:194.4无定义运算:12*(3.6/(2^2-4)+1)#输出结果:表达式出错,除数为0,无意义错误输入:12+s#输出结果:eRRoR!二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。

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

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

void Initstack1(stack1 *s>
{
(*s>->base = (int *>malloc(SIZE * (sizeof(int>>>

(*s>->top = (*s>->base

(*s>->stacksize = INCREMENT 。
}
int Ifempty2(stack2 *s>
<6)中缀转后缀并计算模块:
( 三 > 详细设计
1.元素类型 , 结点类型和指针类型:
typedef struct{
int stacksize 。 int *base 。
int *top 。
}Sqstack1,*stack1 。
typedef struct{
int stacksize 。
char *base 。
{
if(((a=='*'>||(a=='/'>>&&((b=='+'>||(b=='-'>||(b=='#'>>>
5PCzVD7HxA
return '>'

else
return '<'

}
<4)运算符操作模块;
int Operate(int a,char b,int c>
{
int t 。
if(b == '+'> t = a + c
{

数据结构-算术表达式求值(含需求分析和源代码)

数据结构-算术表达式求值(含需求分析和源代码)

需求分析(附代码)一、需求分析(1)首先定义两个栈OPTR、OPND,栈OPTR用于存放运算符,栈OPND 用于存放操作数;定义一个一维数组expr【】存放表达式串。

(2)主函数主要包括两部分:(1)判断运算符优先权,返回优先权高的;(2)操作函数。

(3)开始将‘#’入操作符栈,通过一个函数来判别算术运算符的优先级。

且规定‘#’的优先级最低。

在输入表达式的最后输入‘#’,代表表达式输入结束。

在表达式输入过程中,遇操作数则直接入栈。

遇到运算符则与栈顶运算符比较优先级,当前运算符优先级高(前面的运算还不应执行)则当前运算符入栈,扫描下一符号;否则栈顶运算符出栈,两操作数出栈,进行运算,所得结果入数栈,重新比较当前运算符(注意当前运算符未变)与新栈顶运算符。

如此重复直到栈顶运算符与当前符号均为‘#’,运算结束。

(4)最初实现的加、减、乘、除及带小括号的基本运算,但考虑到实用性,后来的设计中有加上了乘方运算。

在乘方运算中借用了C库中自带的乘方函数pow。

二、概要设计1、设定栈的抽象数据类型定义:ADT Stack {数据对象:D={ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系:R1={ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }约定an端为栈顶,a1端为栈底。

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

DestroyStack(&S)初始条件:栈S已存在。

操作结果:栈S被销毁。

StackEmpty(S)初始条件:栈S已存在。

操作结果:若栈S为空栈,则返回TRUE,否则FALE。

StackLength(S)初始条件:栈S已存在。

操作结果:返回S的元素个数,即栈的长度。

GetTop(S, &e)初始条件:栈S已存在且非空。

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

ClearStack(&S)初始条件:栈S已存在。

数据结构课程设计算术表达式求值-计算器(Word)

数据结构课程设计算术表达式求值-计算器(Word)

高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值,并打印求值过程中运算符栈、操作数栈的变化过程。

第二章系统分析开始运行时界面如下:你可以输入一个表达式,按E对其进行求值。

#include <stdio.h>#include <conio.h>#include <stdlib.h>#include <string.h>#define N 100double numStack[N]={0};//操作数栈int numTop;char opStack[N];//运算符栈int opTop;void print_num(double str1[],int n) {int i;printf("\n操作数栈:\n");for(i=0;i<n;i++)printf("%g ",str1[i]);}void print_op(char str2[],int m) {int j;printf("\n运算符栈:\n");for(j=0;j<m;j++)printf("%c ",str2[j]);}int op(char ch)//判断运算符优先级{if(ch=='+'||ch=='-') return 2;if(ch=='*'||ch=='/') return 3;if(ch=='(') return -1;return 0;}double result(double num1,char op,double num2)//计算{if(op=='+') return num1+num2;if(op=='-') return num1-num2;if(op=='*') return num1*num2;if(op=='/') return num1/num2;return 0;}int compute(char str[]){double num=0;int i=0,j=1,k=1;numTop=opTop=0;while(str[i]!='\0'||opTop>0){if(str[i]>='0'&&str[i]<='9')num=num*10+str[i]-'0';else if( k==1&&str[i]=='-'&&(i==0||op(str[i-1])) )k=-1;else{if(i>0&&!op(str[i-1])&&str[i]!='('&&str[i-1]!=')') {numStack[numTop++]=num*k;if(opTop!=0&&numTop!=0)print_num(numStack,numTop);num=0; j=1; k=1;}if(opTop==0||str[i]=='('){opStack[opTop++]=str[i];print_op(opStack,opTop);}else if(str[i]==')'){while(opTop>0&&opStack[--opTop]!='('){numStack[numTop-2]=result(numStack[numTop-2],opStack[opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop);print_op(opStack,opTop);}numTop--;}if(opStack[opTop]!='(') return 0;}else{if(str[i]=='\0'&&numTop==0) return 0;while(opTop>0&&op(str[i])<=op(opStack[opTop-1])){numStack[numTop-2]=result(numStack[numTop-2],opStack[--opTop],numStack[numTop-1]);if(opTop!=0&&numTop!=0){print_num(numStack,numTop-1); print_op(opStack,opTop);}numTop--;}if(str[i]!='\0')opStack[opTop++]=str[i];if(opTop!=0&&numTop!=0)print_op(opStack,opTop);}}if(str[i]!='\0')i++;}if(numTop!=1||opTop!=0)return 0;return 1;}void menu(){system("cls");printf("_______________________________\n");printf(" Clear(C) | Equal(E) | Quit(Q) \n");printf("-------------------------------\n");}int main(void){int i=0,j=0,k;char str[N]="\0";char num[N]="\0";char save[N]="\0";char ch;double temp;unsigned long temp2;menu();printf("input an expression,press key 'E' to compute\n");ch=getch();while( 1 ){if(ch==')'||op(ch)||ch>='0'&&ch<='9'){str[i++]=ch;str[i]='\0';menu();printf("input an expression,press key 'E' to compute\n"); printf("%s",str);if( ch=='-'&&(i==1||op(str[i-2]))||ch>='0'&&ch<='9' ){num[j++]=ch;num[j]='\0';}elsej=0;}if(ch=='C'||ch=='c'){if(strlen(str))str[--i]='\0';menu();printf("input an expression,press key 'E' to compute\n");printf("%s",str);}if(ch=='E'||ch=='e'){if(compute(str)){printf("\n=%g\n",numStack[0]); j=0; temp=numStack[0];if(temp<0){temp=-temp;num[j++]='-';num[j]='\0';}temp2=(unsigned long)temp;k=1;while(temp2/k>=10) k*=10;while(k){num[j++]=temp2/k+'0';num[j]='\0';temp2=temp2%k;k/=10;}temp=temp-(int)temp;if(temp!=0){num[j++]='.';num[j]='\0';temp+=0.0000005;}for(k=6;k>0;k--){if(temp==0) break;temp*=10;num[j++]=(int)temp+'0';num[j]='\0';temp=temp-(int)temp;}}i=0; j=0; str[0]='\0';}if(ch=='Q'||ch=='q'){printf("\nare you sure to quit?(Y/N)\n");ch=getch();if(ch=='Y'||ch=='y') break;else{menu();printf("input an expression,press key 'E' to compute\n");printf("%s",str);}}ch=getch();}return 0;}第五章系统测试1.先输入: 3+2*5 后按E求值2.再输入:12/4-5 后按E求值3.再输入Q4.输入Y,退出系统。

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

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

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

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

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

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

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

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

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

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

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

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

课程设计报告(20 -20 学年第学期)报告题目:算术表达式求值课程名称:数据结构任课教员:专业:学号:姓名:二0一年月日摘要:现代科学技术高速发展,各种高科技产品频频问世,而各种技术的基础都离不开基本的表达式求值,它虽然简单,但却是任何复杂系统的基本执行操作。

栈是一种重要的线性结构,从数据结构的角度看,它是一种特殊的线性表,具有先入先出的特点。

而算符优先法的设计恰巧符合先入先出的思想。

故我们基于栈这种数据结构,利用算符优先法,来实现简单算术表达式的求值。

关键字:算符优先法;算术表达式;数据结构;栈一、课题概述1、问题描述一个算术表达式是由运算数、运算符、界限符组成。

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

利用算符优先法对算术表达式求值。

2、设计目的(1)通过该算法的设计思想,熟悉栈的特点和应用方法;(2)通过对算符优先法对算术表达式求值的算法执行过程的演示,理解在执行相应栈的操作时的变化过程。

(3)通过程序设计,进一步熟悉栈的基本运算函数;(4)通过自己动手实现算法,加强从伪码算法到C语言程序的实现能力。

3、基本要求:(1)使用栈的顺序存储表示方式;(2)使用算符优先法;(3)用C语言实现;(4)从键盘输入一个符合要求的算术表达式,输出正确的结果。

4、编程实现平台Microsoft Visual C++ 6.0二、设计思路及采取方案1、设计思路:为了实现算符优先法,可以使用两个工作栈。

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

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

表达式求值(数据结构)

表达式求值(数据结构)
ch (3) 当ch != “#” 时, 执行以下工作, 否则
结束算法,此时在OPND栈的栈顶得到 运算结果。
① 若ch是操作数,进OPND栈,从中缀表达式 取下一字符送入ch; ② 若ch是操作符,比较栈外icp(ch)的优先级和 栈内isp(OPTR)的优先级: 若icp(ch) > isp(OPTR),则ch进OPTR栈, 从中缀表达式取下一字符送入ch; 若icp(ch) < isp(OPTR),则从OPND栈退出 a2 和 a1 , 从 OPTR 栈 退 出 θ, 形 成 运 算 指 令 (a1)θ(a2),结果进OPND栈; 若icp(ch) == isp(OPTR) 且ch == “)”,则从 OPTR栈退出栈顶的“(”,对消括号,然后从 中缀表达式取下一字符送入ch;
优先级 操作符
1
单目-、!
2
*、/、%
3
+、-
4 <、<=、>、>=
5
==、!=
6
&&
7
||
一般表达式的操作符有4种类型:
1 算术操作符 如双目操作符(+、-、 *、/ 和%)以及单目操作符(-);
2 关系操作符 包括<、<=、==、!=、 >=、>。这些操作符主要用于比较;
3 逻辑操作符 如与(&&)、或(||)、非 (!);
38
icp (栈外) 0 8 6 4
21
isp叫做栈内(in stack priority)优先数。
icp叫做栈外(in coming priority)优先数。
操作符优先数相等的情况只出现在括号 配对或栈底的“;”号与输入流最后的“;” 号配对时。

最新《数据结构》算术表达式求值

最新《数据结构》算术表达式求值

二课程设计2——算术表达式求值一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码三感想体会与总结算术表达式求值一、需求分析一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

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

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

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

二、程序的主要功能(1)从键盘读入一个合法的算术表达式,输出正确的结果。

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

三、程序运行平台Visual C++ 6.0版本四、数据结构本程序的数据结构为栈。

(1)运算符栈部分:struct SqStack //定义栈{char *base; //栈底指针char *top; //栈顶指针int stacksize; //栈的长度};int InitStack (SqStack &s) //建立一个空栈S{if (!(s.base = (char *)malloc(50 * sizeof(char))))exit(0);s.top=s.base;s.stacksize=50;return OK;}char GetTop(SqStack s,char &e) //运算符取栈顶元素{if (s.top==s.base) //栈为空的时候返回ERROR{printf("运算符栈为空!\n");return ERROR;}elsee=*(s.top-1); //栈不为空的时候用e做返回值,返回S的栈顶元素,并返回OKreturn OK;}int Push(SqStack &s,char e) //运算符入栈{if (s.top-s.base >= s.stacksize){printf("运算符栈满!\n");s.base=(char*)realloc (s.base,(s.stacksize+5)*sizeof(char) ); //栈满的时候,追加5个存储空间if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=5;}*(s.top)++=e; //把e入栈return OK;}int Pop(SqStack &s,char &e) //运算符出栈{if (s.top==s.base) //栈为空栈的时候,返回ERROR{printf("运算符栈为空!\n");return ERROR;}else{e=*--s.top; //栈不为空的时候用e做返回值,删除S的栈顶元素,并返回OKreturn OK;}}int StackTraverse(SqStack &s) //运算符栈的遍历{char *t;t=s.base ;if (s.top==s.base){printf("运算符栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %c",*t); //栈不为空的时候依次取出栈内元素t++;}return ERROR;}(2)数字栈部分:struct SqStackn //定义数栈{int *base; //栈底指针int *top; //栈顶指针int stacksize; //栈的长度};int InitStackn (SqStackn &s) //建立一个空栈S{s.base=(int*)malloc(50*sizeof(int));if(!s.base)exit(OVERFLOW); //存储分配失败s.top=s.base;s.stacksize=50;return OK;}int GetTopn(SqStackn s,int &e) //数栈取栈顶元素{if (s.top==s.base){printf("运算数栈为空!\n"); //栈为空的时候返回ERRORreturn ERROR;}elsee=*(s.top-1); //栈不为空的时候,用e作返回值,返回S的栈顶元素,并返回OKreturn OK;}int Pushn(SqStackn &s,int e) //数栈入栈{if (s.top-s.base >=s.stacksize){printf("运算数栈满!\n"); //栈满的时候,追加5个存储空间s.base=(int*)realloc (s.base,(s.stacksize+5)*sizeof(int) );if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize; //插入元素e为新的栈顶元素s.stacksize+=5;}*(s.top)++=e; //栈顶指针变化return OK;}int Popn(SqStackn &s,int &e) //数栈出栈{if (s.top==s.base){printf(" 运算符栈为空!\n"); //栈为空栈的视时候,返回ERRORreturn ERROR;}else{e=*--s.top; //栈不空的时候,则删除S的栈顶元素,用e返回其值,并返回OKreturn OK;}}int StackTraversen(SqStackn &s) //数栈遍历{int *t;t=s.base ;if (s.top==s.base){printf(" 运算数栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %d",*t); //栈不为空的时候依次输出t++;}return ERROR;}五、算法及时间复杂度1、算法:建立两个不同类型的空栈,先把一个‘# ’压入运算符栈。

表达式求值(数据结构)(2023版)

表达式求值(数据结构)(2023版)

表达式求值(数据结构) 表达式求值(数据结构)1.引言1.1 目的1.2 背景1.3 范围2.表达式类型2.1 算术表达式2.1.1 运算符2.1.2 运算数2.2 逻辑表达式2.2.1 逻辑运算符2.2.2 逻辑运算数2.3 字符串表达式2.3.1 字符串连接运算符2.3.2 字符串操作函数3.表达式求值算法3.1 递归下降分析法3.2 栈表达式求值法3.2.1 中缀表达式转后缀表达式3.2.2 后缀表达式求值4.数据结构4.1 操作数栈4.2 运算符栈4.3 后缀表达式栈5.算法实现步骤5.1 输入表达式5.2 初始化栈5.3 处理表达式字符串5.4 根据算法选择相应的方法求值5.5 输出结果6.实例演示6.1 算术表达式求值示例6.2 逻辑表达式求值示例6.3 字符串表达式求值示例7.测试与验证7.1 正常表达式测试7.2 异常表达式测试7.3 性能测试8.总结与展望8.1 本文主要工作8.2 结果评估8.3 存在问题8.4 后续工作附件:附件1、算术表达式求值示例代码附件2、逻辑表达式求值示例代码附件3、字符串表达式求值示例代码法律名词及注释:1.递归下降分析法: 一种基于上下文无关文法进行递归分析的方法,用于处理表达式求值等问题。

2.栈表达式求值法: 使用栈数据结构进行表达式求值的方法。

3.中缀表达式: 常见的数学表达式写法,运算符位于运算数之间。

4.后缀表达式: 也称为逆波兰表达式,运算符位于运算数之后。

5.操作数栈: 用于存储表达式中的操作数的栈。

6.运算符栈: 用于存储表达式中的运算符的栈。

7.后缀表达式栈: 用于存储后缀表达式的栈。

数据结构与算法课程实验二:算术表达式求值

数据结构与算法课程实验二:算术表达式求值

• 一种方便地求算符优先函数的方法——迭代法
若已知运算符之间的优先关系,可按如下步骤构造 优先函数:
1、对每个运算符a(包括#在内)令f(a)=g(a)=1 2、如果a⋗b且f(a)<=g(b)令f(a)=g(b)+1 3、如果a⋖b且f(a)>=g(b)令g(b)= f(a)+1 4、如果a≐b而f(a) ≠g(b),令
选做内容 1
• 变算符优先矩阵为算符优先函数:
• 在实际实现算符优先分析算法时,一般不 用优先矩阵,而是用两个函数:入栈优先 函数f和比较优先函数g。它们如下定义:
若 θ1⋖θ2 若 θ1≐θ2 若 θ1⋗θ2
则 f(θ1) < g(θ2) 则 f(θ1) = g(θ2) 则 f(θ1) > g(θ2)
实现提示
• (1)设置运算符栈和运算数栈辅助分析算 符优先关系。
• (2)在读入表达式的字符序列的同时,完 成运算符和运算数(整数)的识别处理, 以及相应的运算。
• (3)在识别出运算数的同时,要将其字符 序列形式转换成整数形式。
• (4)在程序的适当位置输出运算符栈、运 算数栈、输入字符和主要操作的内容。
实验二
算术表达式求值
问题描述
• 表达式计算是实现程序设 计语言的基本问题之一, 也是栈的应用的典型例子。 设计一个程序,演示用算 符优先法对算术表达式求 值的过程。
基本要求
• 以字符序列的形式从键盘输入语 法正确的,不含变量的整型表达式。 利用教科书表3.1给出的算符优先关系, 实现对算术四则混合运算表达式的求 值,并仿照教科书的例3.1演示在求值 中运算符栈、运算数栈、输入字符和 主要操作的变化过程。
算符优先关系矩阵
+-*/

数据结构表达式求值

数据结构表达式求值

数据结构表达式求值在计算机科学中,数据结构是组织和存储数据的方式,而表达式求值则是一个常见且重要的任务。

表达式求值可以帮助我们计算数学表达式的结果,无论是简单的四则运算,还是复杂的包含函数和变量的表达式。

让我们从一个简单的算术表达式开始,比如“2 +3 4”。

要计算这个表达式的值,我们不能简单地从左到右依次计算,因为乘法的优先级高于加法。

所以,正确的计算顺序应该是先计算 3 4 = 12,然后再计算 2 + 12 = 14。

为了能够正确地处理表达式中不同运算符的优先级,我们需要使用特定的数据结构和算法。

其中,栈(Stack)是一种非常有用的数据结构。

栈就像是一个只能从一端进出的容器,遵循“后进先出”(Last In First Out,LIFO)的原则。

在表达式求值中,我们可以使用两个栈,一个用来存储操作数(Operand Stack),另一个用来存储运算符(Operator Stack)。

当我们读取表达式中的数字时,将其压入操作数栈;当读取到运算符时,需要和运算符栈顶的运算符比较优先级。

如果当前运算符的优先级高于栈顶运算符,那么将其压入运算符栈;如果当前运算符的优先级低于或等于栈顶运算符,就从操作数栈中弹出相应数量的操作数,进行计算,将结果压回操作数栈,然后再将当前运算符压入运算符栈。

例如,对于表达式“2 +3 4”,我们首先读取到数字 2,将其压入操作数栈。

接着读取到“+”号,此时运算符栈为空,所以将“+”号压入运算符栈。

然后读取到数字 3,压入操作数栈。

再读取到“”号,由于“”号的优先级高于“+”号,将“”号压入运算符栈。

接着读取到数字 4,压入操作数栈。

此时,表达式已经读取完毕。

因为“”号的优先级高于“+”号,所以先从操作数栈中弹出 3 和 4 进行乘法运算,得到 12,将 12 压回操作数栈。

然后从运算符栈中弹出“+”号,从操作数栈中弹出 2 和 12 进行加法运算,得到 14,这就是表达式的最终结果。

数据结构课程设计之算术表达式求值

数据结构课程设计之算术表达式求值

1【实验题目及要求】[问题描述]一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

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

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

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

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

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

(3)考虑算法的健壮性,当表达式错误时,要给出错误原因的提示。

(4) 实现非整数的处理(可选功能)。

2【源代码(C语言)】#include<stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20#define OK 1#define ERROR 0#define OVERLOW 0#define YES 1#define NO 0typedefstruct{char * base;char * top;int stacksize; //最大存储量}OPTR; //字符存储栈typedefstruct{float *base;float *top;int stacksize; //最大存储量}OPND; //数值存储栈int InitOptrStack(OPTR *); //字符栈初始化函数int OptrPush(OPTR *, char); //进字符栈操作int OptrPop(OPTR*, char *); //出字符栈操作int OptrEmpty(OPTR ); //判断字符栈是否为空char GetOptrTop(OPTR); //返回字符栈顶元素int InitOpndStack(OPND *); //数值栈初始化函数int OpndPush(OPND *, float); //进数值栈操作int OpndPop(OPND*, float*); //出数值栈操作int OpndEmpty(OPND ); //判断数值栈是否为空int JudgeChar(char); //判断是否为字符float GetFloat(char *); //接收一个数字char Precede(char, char); //判断优先级操作float Caculate(float,float,char);//计算数值{char ch, noMean, ci;float num, number1, number2;OPTR optr;OPND opnd;//system("color 30");InitOptrStack(&optr);InitOpndStack(&opnd);while(1){printf(" 请输入表达式以“#”开始,以“#”结束\n ");do{ch = getchar();}while(ch !='#'); //忽略前面非‘#’字符OptrPush(&optr, ch);ch = getchar();while(ch != '#' || GetOptrTop(optr) != '#'){if(!JudgeChar(ch)){ //如果输入的是数字num = GetFloat( &ch );OpndPush(&opnd, num);else{ //输入的是字符switch(Precede(GetOptrTop(optr),ch)){case'<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case'=':OptrPop(&optr,&noMean); //左右括号,把左括号出栈ch = getchar ();break;case'>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd,&number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符!\n");system ("PAUSE");exit(0);}break;}//witch}//else}if(opnd.top -opnd.base >= 2){printf(" 俩个括号之间缺少运算符!\n ");system ("PAUSE");exit( 0 );}OpndPop(&opnd,&num); //直接把OPND的栈元素赋值给numprintf(" 运算结果为%.3f\n", num);}system ("PAUSE");}int InitOptrStack(OPTR * OP){OP->base = (char*)malloc((MAXSIZE+1)*sizeof(char));OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OptrPush(OPTR *OP, char ch){*(OP->top) = ch;OP->top++;return OK;}int OptrPop(OPTR *OP, char *ch){if(OP->base == OP->top)return ERROR;else{OP->top--;*ch = *(OP->top);return OK;}}int OptrEmpty(OPTR OP){if(OP.top == OP.base )return YES;elsereturn NO;}char GetOptrTop(OPTR OP){return *(OP.top -1);}int InitOpndStack(OPND * OP){if(!(OP->base = (float*)malloc((MAXSIZE+1)*sizeof(float)))) exit(OVERLOW);OP->top = OP->base;OP->stacksize = MAXSIZE;return OK;}int OpndPush(OPND *OP, float number) {*(OP->top) = number;OP->top++;return OK;}int OpndPop(OPND *OP, float* number) {if(OP->top == OP->base)return ERROR;else{OP->top--;*number = *(OP->top);return OK;}}int OpndEmpty(OPND OP){if(OP.top == OP.base )return YES;elsereturn NO;}int JudgeChar(char ch){if(ch>='0'&&ch<= '9')return NO;elsereturn YES;}float GetFloat(char* ch){int i;float num = 0;for( i = 0; *ch>= '0'&& *ch<= '9'; i++){ num = num*10 + *ch - '0';*ch = getchar();}return num;}char Precede(char a, char b){char ch;switch(a){case'+':case'-': if(b == '*' || b == '/' || b == '(')ch = '<';elsech = '>';break;case'*':case'/': if( b == '(')ch = '<';elsech = '>';break;case'(': if(b == ')')ch = '=';elseif(b == '#'){printf(" 缺少反括号\n");system ("PAUSE");exit(0);}elsech = '<';break;case')': if(b == '('){printf(" 两个括号之间没有符号相连!\n");system("PAUSE");exit(0);}ch = '>';break;case'#': if(b == '#')ch = '=';elseif(b == ')'){printf(" 没有左括号!\n ");system("PAUSE");exit(0);}elsech = '<';break;default: printf(" 输入运算符超出范围! \n ");system ("PAUSE");exit(0);break;}return ch;}float Caculate(float number1, float number2, char ci){float num;switch( ci){case'+': num = number1 + number2; break;case'-': num = number1 - number2; break;case'*': num = number1 * number2; break;case'/': num = number1 / number2; break;}return num;}3【算法思想】根据栈的原理,建立数字栈OPND和运算符号栈OPTR,对读入的字符进行判断,存入不同的栈内,每次读入一个字符就把该字符和运算符栈顶的优先级进行比较,然后选择相应的操作,这是这个程序的核心代码,如下:switch(Precede(GetOptrTop(optr),ch)){case '<':OptrPush(&optr,ch); //栈顶优先级低ch = getchar();break;case '=':OptrPop(&optr,&noMean); //左右括号,把左括号出栈ch = getchar ();break;case '>': //栈顶优先级高if(OpndPop(&opnd, &number2) && OpndPop(&opnd, &number1)){OptrPop(&optr, &ci);num = Caculate(number1, number2, ci ); //出栈计算OpndPush(&opnd, num);}else{printf(" 输入过多运算符!\n");system ("PAUSE");exit(0);}break;}//witch4【实现效果】完全可以实现题目的要求,除了下图的错误提示,本程序还可以提示的错误有:输入过多运算符,缺少反括号,两个括号之间缺少运算符相连,缺少左括号,输入的运算符超出范围等提示。

数据结构算术表达式求值&魔王语言解释

数据结构算术表达式求值&魔王语言解释

一.实验目的1.深入了解栈和队列的特性,以便在实际问题背景下灵活运用他们,同时还将巩固对栈和队列这两种结构的构造方法的理解。

2.加深对mfc的理解。

3.加深对浮点型,字符型,整型之间的转换的熟悉。

二.实验内容1.表达式求值:表达式计算是实现程序设计语言的基本问题,也是栈的应用之一。

设计一个程序,演示用算符优先法对算术表达式求值过程。

2.魔王语言解释:有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释承认能听懂的语言,因为他的语言是有以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2…βm(2)(θδ1δ2…δn)→θδnθδn-1…θδ1θ在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

三.实验步骤(可选)一.表达式求值:此次实验我用了mfc来做,实现了计算器界面的仿真,拓展了程序的功能,使到该程序不仅可以计算整型,还可以计算浮点型,负数;有判断键入的表达式格式的正误,删除错误输入,清除结果的功能;拓展了运算符,增加了平方的运算,分数化的运算,还有说明界面,计算结果序列化、读取序列化结果的功能。

1.定义栈数据类型;2.定义栈的操作,初始化,出栈,入栈;3.编写运算符优先比较函数precede;4.编写计算表达式的函数express;5.编写序列化函数archieve;6.设计计算器仿真界面;7.添加关联变量,编写相关函数。

具体代码如下://栈定义typedef struct {char* base;char* top;int stacksize;}stack;void initstack(stack &s){s.base=(char*)malloc(sizeof(char)*100);s.top=s.base;s.stacksize=100;}char gettop(stack s){char e;e=*(s.top-1);return e;}void push(stack &s,char e){*s.top++=e;}void pop(stack &s,char &e){e=*--s.top;}bool stackisempty(stack s)//empty?{if(s.top==s.base)return 1;else return 0;}char precede(char a,char b) //比较优先级函数{switch(a){case'+':switch(b){case'+':case'-':case'#':case')':return '>';case'*':case'/':case'^'://scase'(':return '<';}case'-':switch(b){case'+':case'-':case'#':case')':return '>';break; case'*':case'/':case'^'://scase'(':return '<';break; }case'*':switch(b){case'#':case'+':case'-':case')':case'*':case'/':return '>';case'^'://scase'(':return '<';}case'/':switch(b){case'#':case'+':case'-':case')':case'*':case'/':return '>';case'^'://scase'(':return '<';}case'(':if(b==')')return '=';elsereturn '<';case')':return '>';case'#':if(b!='#') return '<';else return '=';case'^'://sswitch(b){case'(':return '<';default:return '>';}}}float operate(float a,char s,float b)//运算符操作结果函数{float res=0;switch(s){case'+':res=a+b;break;case'-':res=a-b;break;case'*':res=a*b;break;case'/':res=a/b;break;case'^':res=a*a;break;}return res;}int check(CString str){int lf=0,rg=0;for(int n=0;n<str.GetLength();n++){if(str[n]=='(')lf++;if(str[n]==')')rg++;if(rg>lf)return 1;if(n<str.GetLength()-1)if(!isnum(str[n])&&!isnum(str[n+1])&&str[n+1]!='-'&&str[n+1]!='('&&str[n]!=')')//两个操作符相连return 2;}if(lf!=rg)return 1;//括号不匹配if(!isnum(str[str.GetLength()-1])&&str[str.GetLength()-1]!=')'||(!isnum(str[0])&&str[0]!='('&&str[0]!='-'))//最后一个或第一个是操作付return 2;return 0;//正确返回零}float expression(CString s)//求值函数{stack shu;//数字栈stack fu;//操作符栈initstack(shu);initstack(fu);int n=0;//表达式索引int oc=0;//字符变浮点控制变量float a=0,b=0;//a暂存操作数1,b暂存操作数2,c暂存操作结果c=0;char tem1,tem2,tem3;//弹出中间变量CString st;//把浮点型变成字符型push(fu,'#');//标志表达式开始push(shu,'a');//a标志数的分隔for(;gettop(fu)!='#'||s[n]!='#';oc=0){if(s[n]>=48&&s[n]<=57||s[n]=='.'||(s[n]=='-'&&n==0))//字符为数字或点则入数字栈{push(shu,s[n]);if(n<s.GetLength())n++;}//ifelseif(s[n]=='-')//判断—是减号还是负号switch(s[n-1]){case'+':case'-':case'*':case'/':case'(':push(shu,s[n]);//s【n-1】是以上结果的话,“—”则是负号,入数字栈if(n<s.GetLength())n++;break;default://其他为负号goto youxian;//去比较优先级}//switchelseyouxian: switch(precede(gettop(fu),s[n]))//比较优先级{case'<':push(fu,s[n]);if(s[n]!='(')push(shu,'a');if(n<s.GetLength())n++;break;case'=':pop(fu,tem1);if(n<s.GetLength())n++;break;case'>':pop(fu,tem1);a=0;for(pop(shu,tem2);tem2!='a';pop(shu,tem2))//字符转换成浮点{if(tem2=='-')a=0-a;elseif(tem2=='.'){a=a/pow(10,oc);oc=0;}elsea=(tem2-48)*pow(10,oc++)+a;}//foroc=0;b=0;for(pop(shu,tem3);tem3!='a';pop(shu,tem3))//字符转换成浮点{if(tem3=='-')b=0-b;elseif(tem3=='.'){b=b/pow(10,oc);oc=0;}elseb=(tem3-48)*pow(10,oc++)+b;}//forc=operate(b,tem1,a);if(a==0&&tem1=='/'){MessageBox(NULL,"除数不能为0!",0,0);c=0;zero=1;return 0;}st.Format("%g",c);if(st.GetLength()>=5&&st[st.GetLength()-5]=='e')//科学计数法则要转换change(st);push(shu,'a');oc=0;for(;oc<st.GetLength();oc++)//压入cpush(shu,st[oc]);}//switch}//maxforc=0;oc=0;for(pop(shu,tem2);tem2!='a';pop(shu,tem2))//字符转换成浮点{st.Format("%g",c);//MessageBox(NULL,st,0,0);if(tem2=='-')c=0-c;elseif(tem2=='.'){c=c/pow(10,oc);oc=0;}elsec=(tem2-48)*pow(10,oc++)+c;}//forreturn c;}二.魔王语言解释:(mfc实现)1.定义栈数据类型;2.定义栈的操作,初始化,出栈,入栈;3.编写魔王语言解释函数及将小写字母和中文建立一一对应关系;4.运行调试。

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

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

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

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

二、实验目的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.前言在计算机中,算术表达式由常量、变量、运算符和括号组成。

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

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

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

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

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

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

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

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

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

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

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

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

可以使用两个工作栈。

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

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

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

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

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

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

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

竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一:数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院:化学与材料科学学院专业班级:09级材料科学与工程系pb0920603姓学邮名:李维谷号:pb09206285箱:指导教师:贾伯琪实验时间:20XX年10月10日一、需要分析问题描述:表达式计算是实现程序设计语言的基本问题之一,它的实现是栈的应用的一个典型例子。

设计一个程序,演示通过将数学表达式字符串转化为后缀表达式,并通过后缀表达式结合栈的应用实现对算术表达式进行四则混合运算。

问题分析:在计算机中,算术表达式由常量、变量、运算符和括号组成。

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

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

设置运算符栈(字符型)和运算数栈(浮点型)辅助分析算符优先关系。

在读入表达式的字符序列的同时完成运算符和运算数的识别处理,然后进行运算数的数值转换在进行四则运算。

在运算之后输出正确运算结果,输入表达式后演示在求值中运算数栈内的栈顶数据变化过程,最后得到运算结果。

算法规定:输入形式:一个(:数据结构表达式求值实验报告)算术表达式,由常量、变量、运算符和括号组成(以字符串形式输入)。

为使实验更完善,允许操作数为实数,操作符为(、)、.(表示小数点)、+、-、*、/、^(表示乘方),用#表示结束。

输出形式:演示表达式运算的中间结果和整个表达式的最终结果,以浮点型输出。

程序功能:对实数内的加减乘除乘方运算能正确的运算出结果,并能正确对错误输入和无定义的运算报错,能连续测试多组数据。

测试数据:正确输入:12*(3.6/3+4^2-1)#输出结果:194.4无定义运算:12*(3.6/(2^2-4)+1)#输出结果:表达式出错,除数为0,无意义错误输入:12+s#输出结果:eRRoR!二、概要设计拟采用两种类型的展分别对操作数和操作符进行操作。

数据结构课程设计算术表达式求值

数据结构课程设计算术表达式求值

计算机科学系《数据结构课程设计》报告课题名称:算术表达式求值目录1.问题描述-----------------------------------------------------------32.基本要求-----------------------------------------------------------33.工具/准备工作----------------------------------------------------34.分析与实现--------------------------------------------------------45. 课程设计体会与感悟------------------------------------------161.问题描述从键盘上输入中缀算术表达式,包括括号,计算出表达式的值。

2.基本要求(1)程序能对所输入的表达式做简单的判断,如表达式有错,能给适当提示。

(2)能处理单目运算符:+,-。

3.工具/准备工作在开始项目之前,应回顾复习相关内容。

需要一台计算机装有visual C++。

4.分析与实现对于中缀表达式,一般运算规则如下:(1)先乘方,再乘除,最后加减;(2)同级运算从左算到右;(3)先括号内再括号外;(4)用到的头文件”utility.h”,”lk_stack.h”,”node.h”,”calculator.h”.根据实践经验,可以对运算符设置统一的优先级,从而方便比较。

表中给出了包括加、上面讨论的的+、—为双目运算符,如为单目运算符,编程实现时,可在前面加上0而转化为双目运算符。

如在+、—的前一个字符(如当前字符不是运算符时,规定用0表示)为‘=’或‘(’,则为单目运算符。

具体实现算法时,可设置两个工作栈,一个为操作栈,一个为操作符栈optr,另外一个为操作数栈opnd,算法基本思路如下:(1)将optr栈和opnd栈清空,在optr栈中加入一个‘=‘。

《数据结构 课程设计》表达式求值 实验报告

《数据结构 课程设计》表达式求值 实验报告

实验课程名称专业班级学生姓名学号指导教师20 至 20 学年第学期第至周算术表达式求值演示一、概述数据结构课程设计,要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面,加深对课程基本内容的理解。

同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

在这次的课程设计中我选择的题目是算术表达式求值演示。

表达式计算是实现程序设计语言的基本问题之一,也是栈的应用的一个典型例子。

设计一个程序,演示用算符优先法对算术表达式求值的过程。

深入了解栈和队列的特性,以便在解决实际问题中灵活运用它们,同时加深对这种结构的理解和认识。

二、系统分析1.以字符列的形式从终端输入语法正确的、不含变量的整数表达式。

利用已知的算符优先关系,实现对算术四则混合运算表达式的求值,并仿照教科书的例子在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。

2.一般来说,计算机解决一个具体问题时,需要经过几个步骤:首先要从具体问题抽象出一个适当的数学模型,然后设计一个解决此数学模型的算法,最后编出程序,进行测试,调试直至得到想要的答案。

对于算术表达式这个程序,主要利用栈,把运算的先后步骤进行分析并实现简单的运算!为实现算符优先算法,可以使用两个栈,一个用以寄存运算符,另一个用以寄存操作数和运算结果。

3.演示程序是以用户于计算机的对话方式执行,这需要一个模块来完成使用者与计算机语言的转化。

4.程序执行时的命令:本程序为了使用具体,采用菜单式的方式来完成程序的演示,几乎不用输入什么特殊的命令,只需按提示输入表达式即可。

(要注意输入时格式,否者可能会引起一些错误)5. 测试数据。

三、概要设计一个算术表达式中除了括号、界限符外,还包括运算数据和运算符。

由于运算符有优先级别之差,所以一个表达式的运算不可能总是从左至右的循序执行。

每次操作的数据或运算符都是最近输入的,这与栈的特性相吻合,故本课程设计借助栈来实现按运算符的优先级完成表达式的求值计算。

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

二课程设计2——算术表达式求值一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码三感想体会与总结算术表达式求值一、需求分析一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

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

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

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

二、程序的主要功能(1)从键盘读入一个合法的算术表达式,输出正确的结果。

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

三、程序运行平台Visual C++ 6.0版本四、数据结构本程序的数据结构为栈。

(1)运算符栈部分:struct SqStack //定义栈{char *base; //栈底指针char *top; //栈顶指针int stacksize; //栈的长度};int InitStack (SqStack &s) //建立一个空栈S{if (!(s.base = (char *)malloc(50 * sizeof(char))))exit(0);s.top=s.base;s.stacksize=50;return OK;}char GetTop(SqStack s,char &e) //运算符取栈顶元素{if (s.top==s.base) //栈为空的时候返回ERROR{printf("运算符栈为空!\n");return ERROR;}elsee=*(s.top-1); //栈不为空的时候用e做返回值,返回S的栈顶元素,并返回OKreturn OK;}int Push(SqStack &s,char e) //运算符入栈{if (s.top-s.base >= s.stacksize){printf("运算符栈满!\n");s.base=(char*)realloc (s.base,(s.stacksize+5)*sizeof(char) ); //栈满的时候,追加5个存储空间if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=5;}*(s.top)++=e; //把e入栈return OK;}int Pop(SqStack &s,char &e) //运算符出栈{if (s.top==s.base) //栈为空栈的时候,返回ERROR{printf("运算符栈为空!\n");return ERROR;}else{e=*--s.top; //栈不为空的时候用e做返回值,删除S的栈顶元素,并返回OKreturn OK;}}int StackTraverse(SqStack &s) //运算符栈的遍历{char *t;t=s.base ;if (s.top==s.base){printf("运算符栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %c",*t); //栈不为空的时候依次取出栈内元素t++;}return ERROR;}(2)数字栈部分:struct SqStackn //定义数栈{int *base; //栈底指针int *top; //栈顶指针int stacksize; //栈的长度};int InitStackn (SqStackn &s) //建立一个空栈S{s.base=(int*)malloc(50*sizeof(int));if(!s.base)exit(OVERFLOW); //存储分配失败s.top=s.base;s.stacksize=50;return OK;}int GetTopn(SqStackn s,int &e) //数栈取栈顶元素{if (s.top==s.base){printf("运算数栈为空!\n"); //栈为空的时候返回ERRORreturn ERROR;}elsee=*(s.top-1); //栈不为空的时候,用e作返回值,返回S的栈顶元素,并返回OKreturn OK;}int Pushn(SqStackn &s,int e) //数栈入栈{if (s.top-s.base >=s.stacksize){printf("运算数栈满!\n"); //栈满的时候,追加5个存储空间s.base=(int*)realloc (s.base,(s.stacksize+5)*sizeof(int) );if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize; //插入元素e为新的栈顶元素s.stacksize+=5;}*(s.top)++=e; //栈顶指针变化return OK;}int Popn(SqStackn &s,int &e) //数栈出栈{if (s.top==s.base){printf(" 运算符栈为空!\n"); //栈为空栈的视时候,返回ERRORreturn ERROR;}else{e=*--s.top; //栈不空的时候,则删除S的栈顶元素,用e返回其值,并返回OKreturn OK;}}int StackTraversen(SqStackn &s) //数栈遍历{int *t;t=s.base ;if (s.top==s.base){printf(" 运算数栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %d",*t); //栈不为空的时候依次输出t++;}return ERROR;}五、算法及时间复杂度1、算法:建立两个不同类型的空栈,先把一个‘# ’压入运算符栈。

输入一个算术表达式的字符串(以‘#’结束),从第一个字符依次向后读,把读取的数字放入数字栈,运算符放入运算符栈。

判断新读取的运算符和运算符栈顶得运算符号的优先级,以便确定是运算还是把运算符压入运算符栈。

最后两个‘#’遇到一起则运算结束。

数字栈顶的数字就是要求的结果。

2、时间复杂度:O(n)数据压缩存储栈,其操作主要有:建立栈int Push(SeqStack *S, char x)入栈int Pop(SeqStack *S, char x)出栈。

以上各操作运算的平均时间复杂度为O(n),其主要时间是耗费在输入操作。

六、测试用例如图所示。

最终结果如图所示:七、源代码/*********************************************************************************************** ***第七题算术表达式求值[问题描述]一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。

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

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

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

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

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

************************************************************************************************ ***/#include <stdio.h>#include <string.h>#include <stdlib.h>#include <math.h>#include <conio.h>#include <ctype.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100//#define STACKINCREMENT 10//========================================================// 以下定义两种栈,分别存放运算符和数字//========================================================//*******************运算符栈部分*************************struct SqStack //定义栈{char *base; //栈底指针char *top; //栈顶指针int stacksize; //栈的长度};int InitStack (SqStack &s) //建立一个空栈S{if (!(s.base = (char *)malloc(50 * sizeof(char))))exit(0);s.top=s.base;s.stacksize=50;return OK;}char GetTop(SqStack s,char &e) //运算符取栈顶元素{if (s.top==s.base) //栈为空的时候返回ERROR{printf("运算符栈为空!\n");return ERROR;}elsee=*(s.top-1); //栈不为空的时候用e做返回值,返回S的栈顶元素,并返回OKreturn OK;}int Push(SqStack &s,char e) //运算符入栈{if (s.top-s.base >= s.stacksize){printf("运算符栈满!\n");s.base=(char*)realloc (s.base,(s.stacksize+5)*sizeof(char) ); //栈满的时候,追加5个存储空间if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize;s.stacksize+=5;}*(s.top)++=e; //把e入栈return OK;}int Pop(SqStack &s,char &e) //运算符出栈{if (s.top==s.base) //栈为空栈的时候,返回ERROR{printf("运算符栈为空!\n");return ERROR;}else{e=*--s.top; //栈不为空的时候用e做返回值,删除S的栈顶元素,并返回OKreturn OK;}}int StackTraverse(SqStack &s) //运算符栈的遍历{char *t;t=s.base ;if (s.top==s.base){printf("运算符栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %c",*t); //栈不为空的时候依次取出栈内元素t++;}return ERROR;}//**********************数字栈部分***************************struct SqStackn //定义数栈{int *base; //栈底指针int *top; //栈顶指针int stacksize; //栈的长度};int InitStackn (SqStackn &s) //建立一个空栈S{s.base=(int*)malloc(50*sizeof(int));if(!s.base)exit(OVERFLOW); //存储分配失败s.top=s.base;s.stacksize=50;return OK;}int GetTopn(SqStackn s,int &e) //数栈取栈顶元素{if (s.top==s.base){printf("运算数栈为空!\n"); //栈为空的时候返回ERRORreturn ERROR;}elsee=*(s.top-1); //栈不为空的时候,用e作返回值,返回S的栈顶元素,并返回OKreturn OK;}int Pushn(SqStackn &s,int e) //数栈入栈{if (s.top-s.base >=s.stacksize){printf("运算数栈满!\n"); //栈满的时候,追加5个存储空间s.base=(int*)realloc (s.base,(s.stacksize+5)*sizeof(int) );if(!s.base) exit (OVERFLOW);s.top=s.base+s.stacksize; //插入元素e为新的栈顶元素s.stacksize+=5;}*(s.top)++=e; //栈顶指针变化return OK;}int Popn(SqStackn &s,int &e) //数栈出栈{if (s.top==s.base){printf(" 运算符栈为空!\n"); //栈为空栈的视时候,返回ERRORreturn ERROR;}else{e=*--s.top; //栈不空的时候,则删除S的栈顶元素,用e返回其值,并返回OKreturn OK;}}int StackTraversen(SqStackn &s) //数栈遍历{int *t;t=s.base ;if (s.top==s.base){printf(" 运算数栈为空!\n"); //栈为空栈的时候返回ERRORreturn ERROR;}while(t!=s.top){printf(" %d",*t); //栈不为空的时候依次输出t++;}return ERROR;}//======================================================== // 以下定义函数//======================================================== int Isoperator(char ch) //判断是否为运算符,分别将运算符和数字进入不同的栈{switch (ch){case '+':case '-':case '*':case '/':case '(':case ')':case '#':return 1;default:return 0;}}int Operate(int a, char op, int b) //运算操作{int result;switch(op){case '+':result=a+b;break;case '-':result=a-b;break;case '*':result=a*b;break;case '/':result=a/b;break;}return result;}char Precede(char ch1, char ch2) //运算符优先级的比较{char p;switch(ch1){case '+':case '-':if (ch2=='+'||ch2=='-'||ch2==')'||ch2=='#')p = '>'; //ch1运算符的优先级小于ch2运算符elsep = '<';break;case '*':case '/':if (ch2 == '(')p = '<';elsep = '>';break;case '(':if (ch2 == ')')p = '=';else if (ch2 == '#'){printf(" 表达式错误!运算符不匹配!\n") ;exit(0);}elsep = '<';break ;case ')':if (ch2 == '('){printf(" 表达式错误!运算符不匹配!\n") ;exit(0);}elsep = '>';break ;case '#':if (ch2 == ')'){printf(" 表达式错误!运算符不匹配!\n") ;exit(0);}else if (ch2 == '#')p = '=';elsep='<';break;}return p;}//======================================================== // 以下是求值过程//======================================================== int EvaluateExpression() //参考书p53算法3.4{int a, b, temp, answer;char ch,op,e;char *str;int j = 0;SqStackn OPND; //OPND为运算数字栈SqStack OPTR; //OPTR为运算符栈InitStack(OPTR);Push(OPTR,'#'); //,所以此栈底是'#',因为运算符栈以'#'作为结束标志InitStackn(OPND);// printf("\n\n按任意键开始求解:\n\n");// ch=getch();printf("\n请输入表达式并以'#'结束:\n");str =(char*)malloc(50*sizeof(char));gets(str);ch=str[j]; //ch是字符型的,而e是整型的整数j++;GetTop(OPTR,e); //e为栈顶元素返回值while (ch!='#' || e!='#'){if (!Isoperator(ch)) //遇到数字,转换成十进制并计算{temp=ch-'0'; //将字符转换为十进制数ch=str[j];j++;while(!Isoperator(ch)){temp=temp*10 + ch-'0'; //将逐个读入运算数的各位转化为十进制数ch=str[j];j++;}Pushn(OPND,temp);}else if (Isoperator(ch)) //判断是否是运算符,不是运算符则进栈switch (Precede(e,ch)){case '<' : Push(OPTR,ch); // 栈顶元素优先权低ch = str[j++];printf("\n\n 运算符栈为:\n"); //输出栈,显示栈的变化StackTraverse(OPTR);printf("\n 运算数栈为:\n");StackTraversen(OPND);break;case '=' : Pop(OPTR,op); // 脱括号并接收下一字符ch = str[j++] ;printf("\n\n 运算符栈为:\n");StackTraverse(OPTR);printf("\n 数栈为:\n");StackTraversen(OPND);break;case '>' : Pop(OPTR,op); //弹出最上面两个,并运算,把结果进栈Popn(OPND,b);Popn(OPND,a);Pushn(OPND,Operate(a,op,b));printf("\n\n 运算符栈为:\n");StackTraverse(OPTR);printf("\n 数栈为:\n");StackTraversen(OPND);}else{printf("您的输入有问题,请检查重新输入!");exit(0);}GetTop(OPTR,e); //取出运算符栈最上面元素是否是'#' } //whileGetTopn(OPND,answer); //已输出。

相关文档
最新文档