数据结构课程设计报告(二)表达式求值(计算器)
数据结构课程设计(算术表达式求值)-计算器
高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值，并打印求值过程中运算符栈、操作数栈的变化过程。
第二章系统分析开始运行时界面如下：你可以输入一个表达式，按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，退出系统。
数据结构表达式求值实验报告
竭诚为您提供优质文档/双击可除数据结构表达式求值实验报告篇一：数据结构实验二——算术表达式求值实验报告《数据结构与数据库》实验报告实验题目算术表达式求值学院：化学与材料科学学院专业班级：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.本演示程序中，利用堆栈存储结构存储读入的运算符，输入的限定范围是数字（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.本次作业的核心就是利用堆栈将中序表达式改成后序表达式，然后进行表达式的求值。
数据结构实验报告--表达式求值
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
{
数据结构课程设计-表达式求值【
数据结构课程设计-表达式求值【完整版】．数据结构课程设计——表达式求值大学XXXXXX 《数据结构》课程设计报告班级：学号：姓名：指导老师：页 18 共页 2 第数据结构课程设计——表达式求值目录一算术表达式求值一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结页 18 共页 3 第数据结构课程设计——表达式求值算术表达式求值一、需求分析一个算术表达式是由操作数(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{牰湩晴尨运算符栈为空!\n);return ERROR;}elsee=*(s.top-1); //栈不为空的时候用e做返回值，返回S的栈顶元素，并返回OK页 18 共页 4 第数据结构课程设计——表达式求值return OK;}int Push(SqStack &s,char e) //运算符入栈{if (s.top-s.base >= s.stacksize){牰湩晴尨运算符栈满!\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{牰湩晴尨运算符栈为空!\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){牰湩晴尨运算符栈为空!\n); //栈为空栈的时候返回ERRORreturn ERROR;while(t!=s.top){printf( %c,*t); //栈不为空的时候依次取出栈内元素t++;}页 18 共页 5 第数据结构课程设计——表达式求值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){牰湩晴尨运算数栈为空!\n); //栈为空的时候返回ERRORreturn ERROR;}elsee=*(s.top-1); //栈不为空的时候，用e作返回值，返回S的栈顶元素，并返回OK return OK;int Pushn(SqStackn &s,int e) //数栈入栈{if (s.top-s.base >=s.stacksize){牰湩晴尨运算数栈满!\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;页 18 共页 6 第数据结构课程设计——表达式求值}int Popn(SqStackn &s,int &e) //数栈出栈{if (s.top==s.base){printf( 运算符栈为空!\n); //栈为空栈的视时候，返回ERRORreturn ERROR;}else{e=*--s.top; //栈不空的时候，则删除S的栈顶元素，用e返回其值，并返回OK return 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学号： 100171021330姓名：吴迪指导老师：王方利用栈求表达式的值1、设计思路这个程序的关键是对数字与运算符的判断和运算符优先级的判断，以及出栈的运算。
建立两个栈，分别存储数字与运算符，栈1存运算符，栈2存数字。
依次读取表达式的字符串，先判断是数字还是运算符，如果是数字不能马上压入栈2，因为可能是大于10的数字，应该继续循环，如果还是数字，则利用计算保存数值，直到指到运算符时停止，将计算后的数字压入栈2。
压入运算符之前先将要压入的与栈顶的运算符优先级相比较，如果栈顶是‘（’而当前不是‘）’，则不需比较优先级，直接压入；如果栈顶是‘（’，当前是‘）’，则抵消（弹出‘（’，指向表达式下一个字符）；若当前的运算符优先级大于栈顶的，则压入；若当前的运算符优先级小于栈內时，弹出栈顶的运算符，同时弹出两组数字，经过运算符的运算后再重新压到栈内。
为了方便判断运算结束，在存储运算符之前先将‘#’压入栈1中，在输入表达式时以‚#‛结束，所以可以以运算符==‘#’并且栈1顶==‘#’来结束运算，弹出栈2的数值，即为表达式求值的最终结果。
上述操作的算法步骤：（1）初始化算符S1,数字栈S2;，将‘#’压入算符栈S1中。
（2）读表达式字符=>w。
（3）当栈顶为‘#’并且w也是‘#’时结束；否则循环做下列步骤：（3-1）如果w是数字，存储到m，再经过计算存储到num中。
m=w-‘0’;num=num*pow(10,n)+m;n++;读下一个字符=>w，如果是运算符，则跳出循环；转3-2。
（3-2）w若是运算符，则：（3-2-1）如果栈顶为‘（’并且w为‘）’则‘（’出栈，读下一个字符=>w；转（3）。
（3-2-2）如果栈顶为‘（’或者栈顶优先级小于w优先级，则w入栈，读下一个字符=>w；转（3）。
否则：从算符栈中出栈，并从数字栈中弹出两组数字进行运算，将结果重新压入数字栈，转（3）。
数据结构表达式求值实验报告-无删减范文
数据结构表达式求值实验报告数据结构表达式求值实验报告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. 实现一个能够正确求解算术表达式的程序；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《数据结构》课程设计报告题目简易计算表达式的演示【题目要求】要求：实现基本表达式计算的功能输入：数学表达式，表达式由整数和“+”、“-”、“×”、“/”、“（”、“）”组成输出：表达式的值基本操作：键入表达式，开始计算，计算过程和结果记录在文档中难点：括号的处理、乘除的优先级高于加减1．前言在计算机中，算术表达式由常量、变量、运算符和括号组成。
由于不同的运算符具有不同的优先级，又要考虑括号，因此，算术表达式的求值不可能严格地从左到右进行。
因而在程序设计时，借助栈实现。
算法输入：一个算术表达式，由常量、变量、运算符和括号组成（以字符串形式输入）。
为简化，规定操作数只能为正整数，操作符为+、-*、/、=，用#表示结束。
算法输出：表达式运算结果。
算法要点：设置运算符栈和运算数栈辅助分析算符优先关系。
在读入表达式的字符序列2.的同时，完成运算符和运算数的识别处理，以及相应运算。
2．概要设计2.1 数据结构设计任何一个表达式都是由操作符，运算符和界限符组成的。
我们分别用顺序栈来寄存表达式的操作数和运算符。
栈是限定于紧仅在表尾进行插入或删除操作的线性表。
顺序栈的存储结构是利用一组连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top 指示栈顶元素在顺序栈中的位置，base 为栈底指针，在顺序栈中，它始终指向栈底，即top=base 可作为栈空的标记，每当插入新的栈顶元素时，指针top 增1，删除栈顶元素时，指针top 减1。
2.2 算法设计为了实现算符优先算法。
可以使用两个工作栈。
一个称为OPTR ，用以寄存运算符，另一个称做OPND ，用以寄存操作数或运算结果。
1.首先置操作数栈为空栈，表达式起始符”#”为运算符栈的栈底元素；2.依次读入表达式，若是操作符即进OPND 栈，若是运算符则和OPTR 栈的栈顶运算符比较优先权后作相应的操作，直至整个表达式求值完毕（即OPTR 栈的栈顶元素和当前读入的字符均为”#”）。
数据结构课程设计报告(二)表达式求值(计算器)
课程设计报告课程名称：数据结构课程设计设计题目：表达式求值（计算器）学院：信息科学与工程学院专业：计算机科学与技术（软件外包）姓名：指导教师：二零一五年十二月二十九日一、设计容与要求1、问题描述设计一个算术计算器，能运算包括四则运算、括号的表达式的运算。
2、设计要求实现（）、+、-、*、/、^ 等运算，实现小数和整数混合运算，优先级的处理，能判断算术表达式是否正确等。
二、算法设计1、输入并建立表达式，运用数组结构体构建将整型数字与操作符结合定义运算符的优先级。
typedef struct yxj{char operat;int rank;}yxj;2、分别建立一个操作数栈和操作符栈存放数字和操作符，定义操作符栈第一个元素优先级最低。
3、自左向右扫描字符串遇到字符串中的数字时一律提取转换成double型存入操作数栈。
遇到操作符时，则将当前运算符的优先级数与运算符栈顶元素的优先级数相比较。
若当前运算符的优先级数大，则进栈；反之，则取出栈顶的运算符，并在数栈中连续取出两个栈顶元素作为运算对象进行运算，并将运算结果存入数栈，然后继续比较当前运算符与栈顶元素的优先级。
直到当前运算符进栈。
4、对比运算符进行+ - * /（）^ 运算。
三、程序代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>#define N 100typedef struct yxj{char operat;int rank;}yxj;typedef struct str{char data[N];}zs;void szys(yxj mark[]){yxj os[N];char ch;double ns[N];zs zhan[20];int numb[N];int Len,p=0,q=1,i,o=1,n=0;char data[N];os[0]=mark[0];printf("请输入算术（+ - * / ^）表达式（以 = 结束）：\n");scanf("%s",data);Len=strlen(data);numb[0]=0;for(i=0;i<20;i++)zhan[i].data[0]='\0';for(i=0;i<Len;i++){int t=0;if(data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data[i]=='/'||data[ i]=='('||data[i]==')'||data[i]=='='){int j,k=0;if((data[i]=='='||data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data [i]=='/')&&(data[i-1]=='^'||data[i-1]=='+'||data[i-1]=='-'||data[i-1]=='*'||data[i -1]=='/')){printf("格式错误\n");return;}numb[q++]=i;while(zhan[(p+k)/2].data[0]!='\0'){k++;}for(j=numb[q-2];j<numb[q-1];j++)if(data[j]>='0'&&data[j]<='9'||data[j]=='.')zhan[(p+k)/2].data[t++]=data[j];zhan[(p+k)/2].data[t]='\0';if(zhan[(p+k)/2].data[0]!='\0')ns[n++]=atof(zhan[(p+k)/2].data);p++;for(j=0;j<8;j++)if(mark[j].operat==data[i])break;while(1){if(mark[j].operat=='('){os[o++]=mark[j];break;}else if(mark[j].rank>os[o-1].rank&&mark[j].operat!='(') {os[o++]=mark[j];break;}else{double numb1,numb2,numb;ch=os[--o].operat;if(ch=='+'){numb1=ns[--n];numb2=ns[--n];numb=numb1+numb2;ns[n++]=numb;}if(ch=='-'){numb1=ns[--n];numb2=ns[--n];numb=numb2-numb1;ns[n++]=numb;}if(ch=='*'){numb1=ns[--n];numb2=ns[--n];numb=numb2*numb1;ns[n++]=numb;}if(ch=='/'){numb1=ns[--n];numb2=ns[--n];if(numb1==0){printf("无效操作\n");return;}else{numb=numb2/numb1;ns[n++]=numb;}}if(ch=='^'){numb1=ns[--n];numb2=ns[--n];numb=pow(numb2,numb1);ns[n++]=numb;}}}}else if(data[i]>='0'&&data[i]<='9');else if(data[i]=='.');else{printf("格式错误，请重新输入：\n");szys(mark);break;}}printf("%lf\n",ns[0]);}int main (){yxj mark[9];mark[0].operat='#';mark[0].rank=-1;mark[1].operat='+';mark[1].rank=1;mark[2].operat='-';mark[2].rank=1;mark[3].operat='*';mark[3].rank=2;mark[4].operat='/';mark[4].rank=2;mark[5].operat='(';mark[5].rank=-1;mark[6].operat=')';mark[6].rank=-1;mark[7].operat='=';mark[7].rank=0;mark[8].operat='^';mark[8].rank=3;while(1){char i[N];printf("*****1、计算器*****\n");printf("*****0、退出 *****\n");scanf("%s",&i);if(strcmp(i,"0")==0)break;else if(strcmp(i,"1")==0)szys(mark);elseprintf("没有该选项\n");}}四、运行测试1.正常四则运算2.乘方运算3.除数为零时4.格式出现错误5.小数运算五、结论这次课程设计让我们更加了解大一学到的C和这个学期学到的数据结构。
北京理工大学 数据结构 实验报告 实验二 简易计算器
实验二简易计算器姓名：任子龙学号：1120140167 班级：05111451一.需求分析1.程序要求可对一实数算术表达式进行简单的数学运算，可以识别带+、-、*、/、%、^（乘方）等等运算符及括号的中缀表达式，从键盘上输入一算术表达式（一般为中缀表达式），计算出表达式的值。
2.按照四则运算规则，求表达式的值。
一般规则如下：1）先括号内，再括号外。
2）先乘方，再乘除，后加减。
b.同级运算从左到右顺序执行。
3.有良好的提示信息，引导用户在键盘上输入规定的运算指令；如表达式有误，也应给出相应的提示信息。
4.建立两个工作栈，分别保存运算符，操作数或运算结果。
二.概要设计1.抽象数据类型的定义为实现上述功能，建立两个工作栈；算符为字符型变量，算数为单精度浮点型变量，则需要定义两种数据类型分别存储。
typedef struct StackChar{char c;struct StackChar*next;}SC;typedef struct StackFloat{float f;}SF;2.本程序包含两个模块（1）主程序模块主函数只包含了输入输出部分。
流程为：首先输入算式，然后调用算符优先算法函数EvaluateExpression(s)进行计算，结果输出；然后循环下去，直到输入OUT指令，退出程序；（2）链栈单元模块——实现栈的链式存储的抽象数据类型。
各函数之间的调用关系：三.详细设计1.结点类型typedef struct StackChar{char c;struct StackChar*next;}SC;float f;struct StackFloat*next;}SF;2.子函数（1）算符优先算法的主干函数float EvaluateExpression(char*e)实现算符优先算法主干的函数。
首先判断是算符还是算数，如果是算符，与算符栈栈顶元素进行优先级比较，如果该算符优先级比原栈顶元素优先级高，则进栈，否则进行运算；如果是算数，则入算数栈。
表达式求值 实验报告
表达式求值实验报告表达式求值实验报告一、引言表达式求值是计算机科学中一个重要的概念，它涉及到对数学表达式的计算和求解。
在本次实验中，我们将探讨表达式求值的相关算法和实现方法，并通过编程实现一个简单的表达式求值器。
二、算法原理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.操作数：表达式中用于参与计算的数值或变量。
3.运算符：表达式中用于进行运算的符号，如加减乘除等。
4.括号：用于控制运算优先级和改变运算次序的符号。
三、表达式求值的算法表达式求值的基本思路是通过遍历表达式字符串并利用栈来进行计算。
1.建立一个操作数栈和一个运算符栈。
2.从左到右遍历表达式字符串，依次处理每个字符。
3.如果当前字符是操作数，则直接入操作数栈。
4.如果当前字符是运算符，则进行如下处理：●如果运算符栈为空或栈顶运算符是左括号，则将当前运算符入运算符栈。
●如果当前运算符的优先级高于栈顶运算符的优先级，则将当前运算符入运算符栈。
●如果当前运算符的优先级低于或等于栈顶运算符的优先级，则从运算符栈顶取出一个运算符进行计算，并将结果入操作数栈，直到栈顶运算符的优先级低于当前运算符，然后将当前运算符入运算符栈。
5.如果当前字符是左括号，则将其入运算符栈。
6.如果当前字符是右括号，则从运算符栈顶取出一个运算符进行计算，并将结果入操作数栈，直到取出的运算符是左括号。
7.遍历完表达式字符串后，将运算符栈中剩余的运算符依次取出进行计算，并将结果入操作数栈。
8.操作数栈中最后剩下的元素即为表达式的求值结果。
四、示例代码```pythonclass ExpressionEvaluation:def __init__(self, expression):self.expression = expressionself.operators = []self.operands = []self.precedence = {'+': 1, '.': 1, '': 2, '/': 2}def evaluate(self):for char in self.expression:if char.isdigit():self.operands.append(int(char))elif char in self.precedence:while self.operators andself.operators[.1] != '(' and self.precedence[char] <= self.precedence[self.operators[.1]]:lculate()self.operators.append(char)elif char == '(':self.operators.append(char)elif char == ')':while self.operators[.1] != '(':lculate()self.operators.pop()while self.operators:lculate()return self.operands[.1]def calculate(self):operator = self.operators.pop()operand2 = self.operands.pop()operand1 = self.operands.pop()if operator == '+':self.operands.append(operand1 + operand2)elif operator == '.':self.operands.append(operand1 ●operand2) elif operator == '':self.operands.append(operand1 operand2) elif operator == '/':self.operands.append(operand1 / operand2) expression = \。
数据结构课程设计报告(二)表达式求值(计算器).doc
数据结构课程设计报告(二)表达式求值(计算器).课程设计报告课程名称：数据结构课程设计设计题目：表达式求值（计算器）学院：信息科学与工程学院专业：计算机科学与技术（软件外包）姓名：指导教师：二零一五年十二月二十九日word教育资料.一、设计内容与要求1、问题描述设计一个算术计算器，能运算包括四则运算、括号的表达式的运算。
2、设计要求实现（）、+、- 数据结构课程设计设计题目：表达式求值（计算器）学院：信息科学与工程学院专业：计算机科学与技术（软件外包）姓名：指导教师：二零一五年十二月二十九日word教育资料.一、设计内容与要求1、问题描述设计一个算术计算器，能运算包括四则运算、括号的表达式的运算。
2、设计要求实现（）、+、：\n"); scanf("%s",data); Len=strlen(data); numb[0]=0; for(i=0;i20;i++) zhan[i].data[0]='\0'; for(i=0;i='0'data[i]='9'); else if(data[i]=='.'); else { printf("格式错误，请重新输入：\n"); szys(mark); break; } } printf("%lf\n",ns[0]);}int main (){ yxj mark[9]; mark[0].operat='#'; mark[0].rank=-1; mark[1].operat='+'; mark[1].rank=1; mark[2].operat='-'; mark[2].rank=1; mark[3].operat='*'; mark[3].rank=2; mark[4].operat='/'; mark[4].rank=2; mark[5].operat='('; mark[5].rank=-1; mark[6].operat=')'; mark[6].rank=-1; mark[7].opera该选项\n"); }}四、运行测试1.正常四则运算2.乘方运算3.除数为零时4.格式出现错误5.小数运算五、结论这次课程设计让我们更加了解大一学到的C和这个学期学到的数据结构。
施磊磊的数据结构课程设计及报告2 表达式求值问题
课程设计题目名称表达式求值问题课程名称数据结构课程设计学生姓名施磊磊学号0813022057班级计082指导教师管致锦数据结构课程设计及报告表达式求值一、问题描述实验题目为表达式求值。
要求接受用户输入一个中缀表达式（运算符为加、减、乘、除），然后通过借助于顺序栈实现将其转换为后缀表达式并将其打印，最后求出其值。
设计主函数，使用户可以重复输入中缀表达式，求得表达式的后缀表达式和表达式的值。
二、数据结构算法设计（一）堆栈ADTADT Stack{数据:0个或多个元素的线性序列（a0,a1,...,an-1）,其最大允许长度为MaxStackSize。
运算：Create(): 建立一个空栈。
Destroy(): 撤销一个栈。
IsEmpty(): 若空栈，则返回true；否则返回false。
IsFull(): 若栈满，则返回true；否则返回false。
Top(): 在x中返回栈顶元素。
若操作成功，则返回true；否则返回false。
Push(): 在栈顶插入元素x（入栈）。
若操作成功，则返回true；否则返回false。
Pop(): 从栈中删除栈顶元素（出栈）。
若操作成功，则返回true；否则返回false。
Clear(): 清除堆栈中全部元素。
}（二）顺序栈类在此题目中，借助了c++的模板抽象类来定义栈抽象数据类型，程序如下：顺序堆栈类：includetemplateclass Stack{private:T * stack; //指向数组的指针int top; //栈顶指针int maxTop; //最大栈顶指针public:Stack(); //构建一个构造函数；初始化栈void Push(T item); //进栈T Pop(); //出栈，删除栈顶元素T Peek(); //返回栈顶元素bool EmptyStack(); //判断是否为空栈~Stack() {delete []stack;}; //释放并清空栈的存储空间void Clear(){top=-1;} //清除栈中全部元素三、算法原理（一）头文件名在本程序中，运用的头文件有一些是在平时经常用到的，也有一些是少见甚至是很陌生的。
数据结构课程设计-计算器
数据结构课程设计报告实验一：计算器设计要求1、问题描述：设计一个计算器，可以实现计算器的简单运算，输出并检验结果的正确性，以及检验运算表达式的正确性。
2、输入：不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、*、/、%、(、)。
具体事例如下：3、输出：如果表达式正确，则输出表达式的正确结果；如果表达式非法，则输出错误信息。
具体事例如下：知识点：堆栈、队列实际输入输出情况：正确的表达式对负数的处理表达式括号不匹配表达式出现非法字符表达式中操作符位置错误求余操作符左右出现非整数其他输入错误数据结构与算法描述解决问题的整体思路：将用户输入的中缀表达式转换成后缀表达式，再利用转换后的后缀表达式进行计算得出结果。
解决本问题所需要的数据结构与算法：用到的数据结构是堆栈。
主要算法描述如下：A．将中缀表达式转换为后缀表达式：1. 将中缀表达式从头逐个字符扫描，在此过程中，遇到的字符有以下几种情况：1）数字2）小数点3）合法操作符+ - * / %4）左括号5）右括号6）非法字符2. 首先为操作符初始化一个map<std::string,int> priority，用于保存各个操作符的优先级，其中+ -为0，* / %为13. 对于输入的字符串from和输出的字符串to，采用以下过程：初始化遍历器std::string::iterator it=infix.begin()在当it!=from.end()，执行如下操作4. 遇到数字或小数点时将其加入到后缀表达式：case'1':case'2':case'3':case'4':case'5':case'6':case'7':case '8':case'9':case'0':case'.':{to=to+*it;break;}5. 遇到操作符（+，-，*，/，%）时，如果此时栈顶操作符的优先级比此时的操作符优先级低，则将其入栈，否则将栈中的操作符从栈顶逐个加入到后缀表达式，直到栈空或者遇到左括号，并将此时的操作符加入到栈中，在此过程中需判断表达式中是否出现输入错误：case'+':case'-':case'*':case'/':case'%':{if((it+1)==from.end()){cout<<"输入错误：运算符号右边缺少运算数"<<endl;return false;}if((*it=='*'||*it=='/')&&it==from.begin()){cout<<"输入错误：运算符号左边缺少运算数"<<endl;return false;}if((it+1)!=from.end()&&(*(it+1)=='+'||*(it+1)=='-'||*(it+1)=='*'||*(it+1)=='/' ||*(it+1)=='%')){cout<<"输入错误：运算符号连续出现"<<endl;return false;}to=to+" ";if(sym.empty()){sym.push(*it);break;}tem=sym.top();while(pri[*it]<=pri[tem]&&!sym.empty()&&tem!='('){to=to+tem+" ";sym.pop();if(sym.empty())break;tem=sym.top();}sym.push(*it);break;}6. 遇到“（”时，直接将其加入操作符栈，并且检测输入错误，并且当括号后的第一个符号为-时，说明用户试图输入负号，这种情况我们向目标表达式输出一个0，以达到处理负号的目的：case'(':{if((it+1)==from.end()){cout<<"输入错误：表达式以左括号结尾"<<endl;return false;}//若以+或者-开头，则按照正负号看待，向目标表达式中加入一个0if(*(it+1)=='-'||*(it+1)=='+'){to=to+'0';}if((it+1)!=from.end()&&((*(it+1)=='*'||*(it+1)=='/'||*(it+1)=='%'||*(it+1)==')'))) {cout<<"输入错误：左括号右边不能为运算符号或右括号"<<endl;return false;}if(it!=from.begin()&&(*(it-1)!='+'&&*(it-1)!='-'&&*(it-1)!='*'&&*(it-1)!='/'&&*(it-1)!='%'&&*(it-1)!='(')){cout<<"输入错误：左括号左边不能为运算数或右括号"<<endl;return false;}sym.push(*it);break;}5.遇到“）”时，将栈中的操作符从栈顶逐个弹出并放入后缀表达式中，直到在栈中遇到“（”，并将“（”从栈中弹出：case')':{if((it+1)!=from.end()&&*(it+1)!='+'&&*(it+1)!='-'&&*(it+1)!='*'&&*(it+1)!='/'&&*(it +1)!='%'&&*(it+1)!=')'){cout<<"输入错误：右括号右边不能为运算数"<<endl;return false;}if(it!=from.begin()&&(*(it-1)=='+'||*(it-1)=='-'||*(it-1)=='*'||*(it-1)=='/'||*(it-1)=='%')){cout<<"输入错误：右括号左边不能为运算符号"<<endl;return false;}to=to+" ";if(sym.empty()){cout<<"输入错误：表达式以右括号开始"<<endl;return false;}tem=sym.top();while(tem!='('){to=to+tem+" ";sym.pop();if(sym.empty()){cout<<"输入错误：括号匹配有误"<<endl;return false;}tem=sym.top();}sym.pop();break;}B．计算后缀表达式的主要思想：逐个字符的扫描后缀表达式，遇到单个数字或小数点时则先将其将其存到一个字符串中，当遇到后缀表达式中的分隔符（这里使用空格）时，则将这个字符串转化为数字放到堆栈numstack 中；case'1':case'2':case'3':case'4':case'5':case'6':case'7':case '8':case'9':case'0':case'.':{numtemp+=*it;break;}case' ':{if(numtemp!=""){if(numtemp.find('.')&&numtemp.find('.',(numtemp.find('.')+1))!=string::npos){cout<<"输入错误：小数点数目超出："+numtemp<<endl;return false;}strm.str(numtemp);strm>>d;numstack.push(d);numtemp="";strm.str("");strm.clear();break;}break;}2.遇到操作符+，-，*，/，%时，将堆栈numstack中的栈顶的两个数取出来，进行相应操作的运算，并将结果加入到堆栈numstack 中；case'+':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1+d2);break;}case'-':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1-d2);break;}case'*':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1*d2);break;}case'/':{d2=numstack.top();numstack.pop();if(fabs(d2)<0.0000001){cout<<"输入错误：除数不能为0"<<endl;return false;}d1=numstack.top();numstack.pop();numstack.push(d1/d2);break;}case'%':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();if((fabs(d2-(int)d2))<0.0000001&&(fabs(d1-(int)d1))<0.0000001){int n1=(int)d1;int n2=(int)d2;numstack.push((double)(n1%n2));break;}else{cerr<<"输入错误：求模操作只能作用于整数"<<endl;return false;}}3.直到后缀表达式扫描完并且堆栈numstack中只有一个数值，则此数值为计算的最终结果，否则说明输入有误。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计报告课程名称：数据结构课程设计设计题目：表达式求值（计算器）学院：信息科学与工程学院专业：计算机科学与技术（软件外包）姓名：指导教师：二零一五年十二月二十九日一、设计内容与要求1、问题描述设计一个算术计算器，能运算包括四则运算、括号的表达式的运算。
2、设计要求实现（）、+、-、*、/、^ 等运算，实现小数和整数混合运算，优先级的处理，能判断算术表达式是否正确等。
二、算法设计1、输入并建立表达式，运用数组结构体构建将整型数字与操作符结合定义运算符的优先级。
typedef struct yxj{char operat;int rank;}yxj;2、分别建立一个操作数栈和操作符栈存放数字和操作符，定义操作符栈第一个元素优先级最低。
3、自左向右扫描字符串遇到字符串中的数字时一律提取转换成double型存入操作数栈。
遇到操作符时，则将当前运算符的优先级数与运算符栈顶元素的优先级数相比较。
若当前运算符的优先级数大，则进栈；反之，则取出栈顶的运算符，并在数栈中连续取出两个栈顶元素作为运算对象进行运算，并将运算结果存入数栈，然后继续比较当前运算符与栈顶元素的优先级。
直到当前运算符进栈。
4、对比运算符进行+ - * /（）^ 运算。
三、程序代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>#define N 100typedef struct yxj{char operat;int rank;}yxj;typedef struct str{char data[N];}zs;void szys(yxj mark[]){yxj os[N];char ch;double ns[N];zs zhan[20];int numb[N];int Len,p=0,q=1,i,o=1,n=0;char data[N];os[0]=mark[0];printf("请输入算术（+ - * / ^）表达式（以 = 结束）：\n");scanf("%s",data);Len=strlen(data);numb[0]=0;for(i=0;i<20;i++)zhan[i].data[0]='\0';for(i=0;i<Len;i++){int t=0;if(data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data[i]=='/'||data[ i]=='('||data[i]==')'||data[i]=='='){int j,k=0;if((data[i]=='='||data[i]=='^'||data[i]=='+'||data[i]=='-'||data[i]=='*'||data [i]=='/')&&(data[i-1]=='^'||data[i-1]=='+'||data[i-1]=='-'||data[i-1]=='*'||data[i -1]=='/')){printf("格式错误\n");return;}numb[q++]=i;while(zhan[(p+k)/2].data[0]!='\0'){k++;}for(j=numb[q-2];j<numb[q-1];j++)if(data[j]>='0'&&data[j]<='9'||data[j]=='.')zhan[(p+k)/2].data[t++]=data[j];zhan[(p+k)/2].data[t]='\0';if(zhan[(p+k)/2].data[0]!='\0')ns[n++]=atof(zhan[(p+k)/2].data);p++;for(j=0;j<8;j++)if(mark[j].operat==data[i])break;while(1){if(mark[j].operat=='('){os[o++]=mark[j];break;}else if(mark[j].rank>os[o-1].rank&&mark[j].operat!='(') {os[o++]=mark[j];break;}else{double numb1,numb2,numb;ch=os[--o].operat;if(ch=='+'){numb1=ns[--n];numb2=ns[--n];numb=numb1+numb2;ns[n++]=numb;}if(ch=='-'){numb1=ns[--n];numb2=ns[--n];numb=numb2-numb1;ns[n++]=numb;}if(ch=='*'){numb1=ns[--n];numb2=ns[--n];numb=numb2*numb1;ns[n++]=numb;}if(ch=='/'){numb1=ns[--n];numb2=ns[--n];if(numb1==0){printf("无效操作\n");return;}else{numb=numb2/numb1;ns[n++]=numb;}}if(ch=='^'){numb1=ns[--n];numb2=ns[--n];numb=pow(numb2,numb1);ns[n++]=numb;}}}}else if(data[i]>='0'&&data[i]<='9');else if(data[i]=='.');else{printf("格式错误，请重新输入：\n");szys(mark);break;}}printf("%lf\n",ns[0]);}int main (){yxj mark[9];mark[0].operat='#';mark[0].rank=-1;mark[1].operat='+';mark[1].rank=1;mark[2].operat='-';mark[2].rank=1;mark[3].operat='*';mark[3].rank=2;mark[4].operat='/';mark[4].rank=2;mark[5].operat='(';mark[5].rank=-1;mark[6].operat=')';mark[6].rank=-1;mark[7].operat='=';mark[7].rank=0;mark[8].operat='^';mark[8].rank=3;while(1){char i[N];printf("*****1、计算器*****\n");printf("*****0、退出 *****\n");scanf("%s",&i);if(strcmp(i,"0")==0)break;else if(strcmp(i,"1")==0)szys(mark);elseprintf("没有该选项\n");}}四、运行测试1.正常四则运算2.乘方运算3.除数为零时4.格式出现错误5.小数运算五、结论这次课程设计让我们更加了解大一学到的C和这个学期学到的数据结构。
课设题目要求不仅要求对课本知识有较深刻的了解，同时要求程序设计者有较强的思维和动手能力和更加了解编程思想和编程技巧。
这次课程设计也让我们有一个深刻的体会，那就是细节决定成败，编程最需要的是严谨，如何的严谨都不过分，往往检查了半天发现错误发生在某个括号，分号，引号，或者数据类型上。
程序设计时，也不要怕遇到错误，在实际操作过程中犯的一些错误还会有意外的收获。
在具体操作中这学期所学的数据结构的理论知识得到巩固，达到课程设计的基本目的，也发现自己的不足之出，在以后的上机中应更加注意，同时体会到C语言具有的语句简洁，使用灵活，执行效率高等特点。
这个程序是我们3个人完成的，我们的工作是一个团队的工作，团队需要个人，个人也离不开团队，必须发扬团结协作的精神。
某个人的离群都可能导致导致整项工作的失败。
实习中只有一个人知道原理是远远不够的，必须让每个人都知道，否则一个人的错误，就有可能导致整个工作失败。
团结协作是我们成功的一项非常重要的保证。
而这次课程设计也正好锻炼我们这一点，这也是非常宝贵的。