数据结构课程设计计算器
数据结构课程设计(算术表达式求值)-计算器
高级语言程序设计《算术表达式求值》课程设计报告算术表达式求值系统可以实现实现对算术四则混合运算表达式求值，并打印求值过程中运算符栈、操作数栈的变化过程。
第二章系统分析开始运行时界面如下：你可以输入一个表达式，按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.实验内容：实现计算器类中l p、rp和operate函数；完善计算器类evaluate函数，增加对输入的合法性检查，包括滤掉所有非法输入及处理左右括号不配对的输入；编制应用程序测试这个计算器；3.程序简介：该计算器能够过滤字母，即当输入的字符串中有字母的时候，会自动过滤掉；当输入的字符串不合法时，输出错误提示，本程序将会对下列的输入进行合法检验(56-23)/8-4# 期望结果：0.12534+p(u89-12.3)k/3# 期望结果：59.566789.5*749+25)# 期望结果：输入有误(8*(7-4)# 期望结果：输入有误65*(72+98)(70-45) # 期望结果：输入有误6*# 期望结果：输入有误)5+3(# 期望结果：输入有误9….0878+1.2# 期望结果：10.28784.算法设计介绍：先定义两个堆栈，一个存放符号，一个存放数字，两个函数l p和rp是定义加减乘除以及括号的优先级的。
Clear函数是检验其合法性的。
Operate函数是进行两个数字之间的运算，只有两个数和一个运算符。
evaluate函数是过滤字符串以及计算结果的。
当输入一个字符串之后，先判断其是否合法，再进行过滤字母和小数点的操作，然后再进行计算。
当数字进栈的时候，若是浮点数，则现将存进栈的单个数字乘以相应的位权再相加转化成浮点数，再进行计算操作。
5.困难及解答编这个程序的时候，一开始基本上没什么思路，后来请教了郑鹏同学，多亏郑鹏同学指点迷津，帮助我完成了这个计算器的设计，其实这个计算器还有很多不足的地方，我本来打算先过滤字母和小数点着，可是思路不清晰，导致编完之后的程序总是运行不出来，后来请教了郑鹏同学，在听完他的讲解之后，基本上明白了大体的思路，所以就仿照了郑鹏同学的算法，这个程序不是自己独立完成的，是得益于郑鹏同学的帮助。
6.心得我逐渐意识到，自己平时编的程序太少了，少的都可怜。
数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.
数据结构课程设计系别电子信息系专业计算机科学与技术班级学号4090113姓名王健指导教师党群成绩2011年7 月14 日目录一、课程题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、心得体会及总结 (12)数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是：1.1 输入并建立多项式；1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；1.3 求多项式a、b的导函数；1.4 计算多项式在x处的值；1.5多项式a和b相加，建立多项式a+b；1.6 多项式a和b相减，建立多项式a-b。
2、设计思路:2.1 定义线性表的动态分配顺序存储结构；2.2 建立多项式存储结构，定义指针*next2.3利用链表实现队列的构造。
每次输入一项的系数和指数，可以输出构造的一元多项式2.4演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。
多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en3、设计思路分析要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表，所以我将结点结构体定义为运用尾插法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b，a+b的求和运算等同于单链表的插入问题（将单链表polyn p中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。
为了实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q结点的指数项，由此得到下列运算规则：① 若p->expn<q->expn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。
数据结构课程设计(简单计算器C语言)
郑州师范学院信息科学与技术学院《简单计算器》课程设计报告设计题目：简单计算器班级：B15计科二班组长：组员：指导教师：完成日期：2016 年12 月23 日成绩：摘要本次选做的课程设计是实现简单计算器的问题。
计算器是一个常用的运算工具，本次课题要求用程序语言的方式解决问题。
此问题仅使用数据结构中的栈操作就可以解决此问题。
而在为了方便使用，添加了easyx图形库实现了UI设计。
为了接近平常使用的计算器，特地创建死循环而且添加了“CE”清空输入和“<-”删除键来控制输入错误或者循环使用的问题。
在UI方面主要是实现按键和点击响应等交互，方便输入和修改，在程序框上面有输入和显示结果的文本框。
在计算过程中，以栈出栈进站的特性把中缀形式的算数表达式转化为计算机方便计算的后缀表达式，最后计算出结果以文本方式显示在结果输出框内。
目录摘要 (I)目录 (II)1需求分析 (3)1.1功能简介及分析 (3)1.2设计平台 (3)2概要设计 (3)2.1 Trans函数 (3)2.2 Compvalue 函数 (4)2.3 GetKey函数 (4)3详细设计和实现 (4)3.1转化为逆波兰式 (4)3.2计算逆波兰式 (6)3.3实现流程图 (7)3.3部分具体程序 (8)4调试与操作说明 (13)4.1调试情况 (13)4.2操作说明 (14)5设计总结 (15)参考文献 (16)1需求分析1.1功能简介及分析本次选做的课程设计是实现简单的计算器并且添加UI的交互。
此计算器是以软件的形式实现的计算器，运行在windows系统。
计算器在功能上分为三类，分别是：常见计算器,专用计算器,综合功能计算器。
常见的计算器又分为四种：①简单型计算器：只实现基本的加减乘除和括号运算。
②科学型计算器：可以进行乘方、开方、指数、对数、三角函数、统计等方面的运算，又称函数计算器。
③程序员计算器：专门为程序员设计的计算器, 主要特点是支持And, Or, Not, Xor：最基本的与或非和异或操作, 移位操作Lsh, Rsh：全称是Left Shift和Right Shift，也就是左移和右移操作，你需要输入你要移动的位数（不能大于最大位数）RoL, RoR：全称是Rotate Left和Rotate Right，对于RoL来讲，就是向左移动一位，并将移出的那位补到最右边那位上，RoR类似。
数据结构课程设计_实验报告(一)表达式求值(计算器)
数据结构课程设计实验报告起止时间：2015.12.28-2015.12.311、输入：tan452、输出：13、执行结果：：设计过程中遇到的问题及解决办法：问题：算数表达式以字符串输入，操作数和操作符的提取；解决办法：两两操作符之间如有数字将中间的数字提取强制转换成double型；参考文献：（在设计中参考的书籍、网站等资料）1. 朱振元，《数据结构——C++语言描述》，清华大学出版社，2008年，页码：2. /detail/gszhouyi/738777指导老师评议：成绩评定：指导教师签名：附件：（程序源代码）#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>#define N 100#define pai 3.1415926typedef struct yxj{char operat;int rank;}yxj;typedef struct str{char data[N];}zs;void sjhs(void){char s[10],a[10];double y,x;printf("请输入(sin cos tan 角度制)表达式：\n");scanf("%s",s);if(strstr(s,"sin")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]<='9')s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=sin(x*pai/180);}else if(strstr(s,"cos")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]<='9')s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=cos(x*pai/180);}else if(strstr(s,"tan")!=0){int i=0,j=0;while(s[i]!='\0'){if(s[i]>='0'&&s[i]<='9')s[j++]=s[i];i++;}s[j]='\0';x=atof(s);y=tan(x*pai/180);}else{printf("格式错误\n");return;}printf("%lf\n",y);printf("*****1、继续*****\n");printf("*****0、返回上一层*****\n");scanf("%s",a);if(strcmp(a,"0")==0)return;else if(strcmp(a,"1")==0)sjhs();elseprintf("没有该选项\n");}void szys(yxj mark[]){yxj os[N];char a[10];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];ns[0]=0;printf("请输入算术（+ - * / ^）表达式（以= 结束）：\n");scanf("%s",data);if(strcmp(data,"+")==0||strcmp(data,"-")==0||strcmp(data,"*")==0||strcmp(data,"/")==0 ||strcmp(data,"^")==0||strcmp(data,"=")==0){printf("格式错误\n");return;}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;switch(ch=os[--o].operat){case '+':{numb1=ns[--n];numb2=ns[--n];numb=numb1+numb2;ns[n++]=numb;break;}case '-':{numb1=ns[--n];numb2=ns[--n];numb=numb2-numb1;ns[n++]=numb;break;}case '*':{numb1=ns[--n];numb2=ns[--n];numb=numb2*numb1;ns[n++]=numb;break;}case '/':{numb1=ns[--n];numb2=ns[--n];if(numb1==0){printf("无效操作\n");return;}else{numb=numb2/numb1;ns[n++]=numb;}break;}case '^':{numb1=ns[--n];numb2=ns[--n];numb=pow(numb2,numb1);ns[n++]=numb;break;}}}}}else if(data[i]>='0'&&data[i]<='9');else if(data[i]=='.');else{printf("格式错误，请重新输入：\n");szys(mark);break;}}printf("%lf\n",ns[0]);printf("*****1、继续*****\n");printf("*****0、返回上一层*****\n");scanf("%s",&a);if(strcmp(a,"0")==0)return;else if(strcmp(a,"1")==0)szys(mark);elseprintf("没有该选项\n");}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[10];printf("*****1、四则运算计算器*****\n");printf("*****2、三角函数计算器*****\n");printf("*****0、退出*****\n");scanf("%s",&i);if(strcmp(i,"0")==0)break;else if(strcmp(i,"1")==0)szys(mark);else if(strcmp(i,"2")==0)sjhs();elseprintf("没有该选项\n");}}。
数据结构课程设计-计算器
数据结构课程设计报告实验一：计算器设计要求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中只有一个数值，则此数值为计算的最终结果，否则说明输入有误。
c设计计算器课程设计
c 设计计算器课程设计一、课程目标知识目标：1. 学生能理解计算器的基本原理和功能，掌握计算器的基本操作方法。
2. 学生能够运用计算器解决基本的数学运算问题，如加减乘除、百分比计算等。
3. 学生能够理解并运用计算器上的科学计算功能，如平方根、指数运算等。
技能目标：1. 学生能够熟练操作计算器，快速进行数值输入、计算和结果读取。
2. 学生能够运用计算器进行实际问题的计算，如购物找零、时间计算等。
3. 学生能够通过计算器解决一些简单的数学问题，培养解决问题的能力和逻辑思维能力。
情感态度价值观目标：1. 学生培养对计算器的正确使用态度，明白计算器是辅助工具，提高计算效率的同时，不应过度依赖。
2. 学生在合作交流中使用计算器，培养团队合作意识和分享精神。
3. 学生通过计算器的运用，增强对数学学科的兴趣，认识到数学与生活的紧密联系。
课程性质：本课程属于实践操作类课程，注重培养学生的动手操作能力和实际问题解决能力。
学生特点：学生处于小学高年级阶段，对计算器有一定了解，好奇心强，喜欢动手操作。
教学要求：教师应引导学生通过实践操作，掌握计算器的使用方法，将计算器与实际生活问题相结合，提高学生的数学应用能力。
同时，注重培养学生的团队合作意识和正确使用计算器的态度。
在教学过程中，关注学生的学习成果，及时进行教学评估和调整。
二、教学内容1. 计算器的基本结构：介绍计算器的各个部分及其功能，如显示屏、键盘、电源等。
教材章节：《计算器与计算法则》第一章内容列举：计算器按键的功能及操作方法。
2. 计算器的基本操作：教授加减乘除、百分比、平方根、指数等基本运算。
教材章节：《计算器与计算法则》第二章内容列举：各类运算的操作步骤及注意事项。
3. 计算器在生活中的应用：通过实例教授计算器解决实际问题，如购物找零、时间计算等。
教材章节：《计算器与计算法则》第三章内容列举：实际案例及解决方法。
4. 科学计算器的使用：针对高年级学生，介绍科学计算器的拓展功能，如三角函数、对数等。
数据结构课程设计报告(二)表达式求值(计算器)
课程设计报告课程名称：数据结构课程设计设计题目：表达式求值（计算器）学院：信息科学与工程学院专业：计算机科学与技术（软件外包）姓名：指导教师：二零一五年十二月二十九日一、设计容与要求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和这个学期学到的数据结构。
课程设计设计计算器
课程设计设计计算器一、教学目标本课程的学习目标包括知识目标、技能目标和情感态度价值观目标。
知识目标要求学生掌握计算器的基本原理和使用方法，理解计算器在数学和科学领域的应用。
技能目标要求学生能够熟练操作计算器，进行基本的算术运算、科学计算和数据处理。
情感态度价值观目标要求学生培养对科学技术的兴趣和好奇心，提高解决实际问题的能力，培养创新精神和团队合作意识。
通过分析课程性质、学生特点和教学要求，我们将目标分解为具体的学习成果。
课程目标明确，有利于学生和教师清晰地了解课程的预期成果，为后续的教学设计和评估提供依据。
二、教学内容根据课程目标，我们选择和了以下教学内容：1.计算器的基本原理：介绍计算器的电路结构、工作原理和编程方法。
2.计算器的使用方法：讲解计算器的各种功能键、操作界面和操作步骤。
3.计算器在数学领域的应用：举例说明计算器在代数、几何、概率等数学领域的应用。
4.计算器在科学领域的应用：介绍计算器在物理、化学、生物等科学领域的应用实例。
5.计算器编程：教授计算器的基本编程语言和编程技巧，让学生能够编写简单的计算器程序。
教学大纲将按照以上内容的安排和进度进行教学，确保内容的科学性和系统性。
三、教学方法为了激发学生的学习兴趣和主动性，我们选择以下教学方法：1.讲授法：教师讲解计算器的基本原理、使用方法和应用领域。
2.讨论法：学生分组讨论计算器编程技巧和解决实际问题的方法。
3.案例分析法：分析计算器在数学和科学领域中的应用案例，让学生加深理解。
4.实验法：学生动手操作计算器，进行编程和实践，提高操作技能。
通过多样化的教学方法，我们能够激发学生的学习兴趣，培养他们的创新精神和团队合作意识。
四、教学资源为了支持教学内容和教学方法的实施，我们选择和准备了以下教学资源：1.教材：选用权威、实用的计算器教材，为学生提供系统的学习材料。
2.参考书：提供相关的计算器参考书籍，丰富学生的知识储备。
3.多媒体资料：制作课件、视频等多媒体资料，生动展示计算器的使用和应用。
数据结构与算法课程设计--模拟简单计算器
数据结构与算法课程设计--模拟简单计算器数据结构与算法课程设计模拟简单计算器在计算机科学领域中，数据结构和算法是非常重要的基础知识。
本次课程设计的目标是模拟一个简单计算器，通过这个实践项目，深入理解和应用数据结构与算法的相关知识。
首先，让我们来明确一下简单计算器需要实现的功能。
它应该能够进行基本的四则运算，即加法、减法、乘法和除法。
同时，还需要支持输入多个操作数和运算符，能够按照正确的运算顺序进行计算。
为了实现这个简单计算器，我们需要选择合适的数据结构来存储输入的操作数和运算符。
考虑到操作的顺序性和灵活性，栈这种数据结构是一个不错的选择。
栈具有先进后出的特点，可以方便地处理运算的优先级。
接下来，我们开始设计算法。
当用户输入一个表达式时，程序需要对其进行解析。
首先，将表达式中的数字和运算符分别提取出来，并按照顺序存储在相应的栈中。
在计算过程中，从运算符栈中取出运算符，从操作数栈中取出相应的操作数进行计算，将结果重新压入操作数栈中。
在具体的实现过程中，我们需要处理一些特殊情况。
例如，除数不能为零的情况。
当遇到除法运算且除数为零时，程序应该给出相应的错误提示。
另外，对于表达式的合法性也需要进行检查。
比如，输入的表达式是否符合基本的数学运算规则，是否存在多余的字符或不匹配的括号等。
如果表达式不合法，程序也需要给出明确的提示信息，以便用户能够及时修正。
为了提高程序的可读性和可维护性，我们采用模块化的编程思想。
将表达式解析、运算处理、错误检查等功能分别封装成独立的函数，这样在后续的调试和优化过程中会更加方便。
｀｀｀pythonclass Stack:def ＿_init__(self)：selfitems ＝def push(self, item)：selfitemsappend(item)def pop(self)：if not selfis_empty(）：return selfitemspop(）else:return Nonedef is_empty(self)：return len(selfitems) ＝＝ 0def calculate(expression)：operand_stack ＝ Stack(）operator_stack ＝ Stack(）num ＝＂＂for char in expression:if charisdigit(）：num ＋＝ charelif char in ＂＋／＂：if num!＝＂＂：operand_stackpush(int(num)）num ＝＂＂operator_stackpush(char)if num!＝＂＂：operand_stackpush(int(num)）while not operator_stackis_empty(）：operator ＝ operator_stackpop(）operand2 ＝ operand_stackpop(）operand1 ＝ operand_stackpop(）if operator ＝＝＇＋＇：result ＝ operand1 ＋ operand2 elif operator ＝＝＇＇：result ＝ operand1 operand2elif operator ＝＝＇＇：result ＝ operand1 operand2elif operator ＝＝＇／＇：if operand2 ＝＝ 0:print(＂除数不能为零！＂）returnresult ＝ operand1 ／ operand2 operand_stackpush(result)return operand_stackpop(）测试代码expression ＝＂2+34-5/2"print(calculate(expression)）｀｀｀在上述代码中，我们首先定义了一个栈类`Stack`，用于存储操作数和运算符。
数据结构课程设计(一元稀疏多项式计算器)
实习报告：1.5题一元稀疏多项式计算器题目：设计一个一元稀疏多项式简单计算器班级：计科一班姓名：康宇学号：10061014 完成日期：2013.4.15一、需求分析1、一元稀疏多项式简单计算器的功能是：1）输入并建立多项式；2）输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；3）多项式a和b相加，建立多项式a+b；4）多项式a和b相减，建立多项式a-b。
5）计算多项式在x处的值；6）求多项式a、b的导函数；2、测试数据：1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7);2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=(-7.8x^15-1.2x^9+12x^-3-x);3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);4、(x+x^3)+(-x-x^3)=0;5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200);6、(x+x^2+x^3)+0=x+x^2+x^3.二、概要设计为实现上述程序功能，应以有序链表来表示多项式的系数和指数。
定义线性表的动态分配顺序存储结构；建立多项式存储结构，定义指针*next利用链表实现队列的构造。
每次输入一项的系数和指数，可以输出构造的一元多项式演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。
1、元素类型、结点类型和指针类型：typedef struct LNode{float xishu; //系数int zhishu; //指数struct LNode *next;} LNode,*Linklist;2、建立两个全局链表指针，Linklist List1=NULL;Linklist List2=NULL;用来存放两个多项式，然后在main（）函数里调用输入函数。
数据结构课程设计报告(二)表达式求值(计算器).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和这个学期学到的数据结构。
数据结构课程设计计算器
数据结构课程设计计算器在计算机科学的学习中，数据结构课程设计是一个非常重要的实践环节。
而本次课程设计的主题是实现一个计算器，这不仅考验了我们对数据结构的理解和运用能力，还锻炼了我们的编程思维和解决实际问题的能力。
一、需求分析在开始设计之前，我们首先需要明确计算器的功能需求。
一个基本的计算器应该能够支持常见的四则运算（加、减、乘、除），以及处理括号的优先级。
此外，还应该能够处理整数和浮点数的运算，并且具备一定的错误处理能力，比如输入非法字符或表达式错误时能够给出相应的提示。
二、数据结构选择为了实现上述功能，我们需要选择合适的数据结构来存储和处理表达式。
栈是一种非常适合的数据结构，因为它具有后进先出（LIFO）的特性，可以方便地处理括号和运算符的优先级。
我们可以使用两个栈，一个用来存储操作数（数字），另一个用来存储运算符。
在处理表达式时，从左到右依次读取字符，如果是数字，则将其压入操作数栈；如果是运算符，则根据运算符的优先级与栈顶运算符进行比较，决定是直接压入运算符栈还是先进行运算。
三、算法设计1、表达式转换首先，需要将用户输入的中缀表达式转换为后缀表达式。
中缀表达式如“（2 ＋ 3) 4 5”，后缀表达式则是“2 3 ＋4 5 ”。
转换的过程中，通过栈来处理括号和运算符的优先级。
2、计算后缀表达式得到后缀表达式后，使用操作数栈进行计算。
从左到右读取后缀表达式的字符，如果是操作数，则压入栈中；如果是运算符，则从栈中弹出两个操作数进行相应的运算，并将结果压回栈中。
最后，栈顶元素即为计算结果。
3、错误处理在整个计算过程中，需要对用户输入的表达式进行错误检查。
例如，检查是否存在非法字符、括号是否匹配、除数是否为零等情况。
如果发现错误，及时给出提示信息。
四、代码实现以下是使用 C+＋语言实现计算器的部分代码示例：｀｀｀cppinclude ＜iostream>include ＜stack>include ＜string>／／判断字符是否为数字bool isDigit(char c) ｛return c ＞＝＇0' ＆＆ c ＜＝＇9'；｝／／计算运算符的优先级int precedence(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 ＝＝＇（＇）｛opStackpush(c)；｝ else if （c ＝＝＇）＇）｛while （！opStackempty(）＆＆ opStacktop(）！＝＇（＇）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpop(）；｝ else ｛while （！opStackempty(）＆＆ precedence(opStacktop(））＞＝precedence(c)）｛postfix ＋＝ opStacktop(）；opStackpop(）；｝opStackpush(c)；｝｝while （！opStackempty(））｛postfix ＋＝ opStacktop(）；opStackpop(）；｝return postfix;｝／／计算后缀表达式的值double evaluatePostfix(std:：string postfix) ｛std:：stack<double> operandStack;for （char c ： postfix) ｛if （isDigit(c)）｛operandStackpush(c ＇0'）；｝ else ｛double operand2 ＝ operandStacktop(）；operandStackpop(）；double operand1 ＝ operandStacktop(）；operandStackpop(）；switch （c) ｛case ＇＋＇：operandStackpush(operand1 ＋ operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇＇：operandStackpush(operand1 operand2)；break;case ＇／＇：if （operand2!＝ 0) ｛operandStackpush(operand1 ／ operand2)；｝ else ｛std:：cout ＜＜＂除数不能为零！＂＜＜ std:：endl; return －1;｝break;｝｝｝return operandStacktop(）；｝int main(）｛std:：string infixExpression;std:：cout ＜＜＂请输入表达式：＂；std:：cin ＞＞ infixExpression;std:：string postfixExpression ＝ infixToPostfix(infixExpression)；double result ＝ evaluatePostfix(postfixExpression)；std:：cout ＜＜＂结果：＂＜＜ result ＜＜ std:：endl;return 0;｝｀｀｀五、测试与优化在完成代码实现后，需要进行充分的测试以确保计算器的功能正确。
数据结构计算器实验报告
数据结构计算器实验报告数据结构计算器实验报告引言：数据结构是计算机科学中非常重要的一门课程，它研究了数据的组织、存储和管理方式，以及对数据进行操作和处理的算法和技术。
在本次实验中，我们设计了一个基于数据结构的计算器，旨在通过实践应用数据结构的知识，提高我们的编程能力和算法思维。
一、设计思路我们的计算器主要有两个功能：进行四则运算和进行括号匹配。
为了实现这两个功能，我们选择了栈这一数据结构。
栈是一种具有后进先出（LIFO）特点的数据结构，非常适合用来处理括号匹配和运算符的优先级。
二、括号匹配算法在进行四则运算之前，我们首先需要对输入的表达式进行括号匹配的检查。
我们使用了一个栈来实现这一功能。
算法的基本思路是，遍历表达式中的每个字符，当遇到左括号时，将其入栈；当遇到右括号时，将栈顶元素出栈，并判断出栈的元素是否与当前右括号匹配。
如果匹配，则继续遍历下一个字符；如果不匹配，则说明表达式存在括号不匹配的错误。
三、四则运算算法当表达式通过了括号匹配的检查后，我们就可以进行四则运算了。
我们使用两个栈来实现这一功能，一个栈用来存储操作数，另一个栈用来存储运算符。
算法的基本思路是，遍历表达式中的每个字符，当遇到数字时，将其入操作数栈；当遇到运算符时，将其入运算符栈，并根据运算符的优先级进行相应的操作。
四、运算符优先级为了正确计算表达式的值，我们需要定义运算符的优先级。
一般来说，乘法和除法的优先级高于加法和减法。
为了实现这一功能，我们可以使用一个优先级表来存储运算符的优先级。
在进行运算时，我们可以通过比较栈顶运算符和当前运算符的优先级来决定是否进行运算。
五、实验结果经过我们的努力，我们成功地实现了一个基于数据结构的计算器。
我们对该计算器进行了多组测试，包括括号匹配、四则运算等不同情况。
在所有的测试中，我们的计算器都能正确地输出结果，并且在处理大规模表达式时也能保持较好的性能。
六、总结与展望通过本次实验，我们深入理解了数据结构的应用和算法的设计。
运用数据结构实现计算器(2023版)
运用数据结构实现计算器运用数据结构实现计算器1.简介本文档将介绍如何使用数据结构来实现一个计算器。
计算器是一种用于执行数学运算的工具，通过输入表达式来计算结果。
我们将使用数据结构来存储和处理表达式中的数据和运算符。
2.功能需求我们的计算器将具有以下功能：●支持基本的四则运算（加法、减法、乘法、除法）●支持括号运算●支持多位数和小数运算●支持优先级运算（乘法和除法的优先级高于加法和减法）3.数据结构设计我们将使用以下数据结构来实现计算器：●栈（Stack）：用于存储运算符和括号，以实现运算符优先级处理和括号匹配。
●队列（Queue）：用于存储数值和中间结果，以实现表达式的计算和保存结果。
4.算法设计计算器的核心算法如下：●表达式解析：将输入的表达式解析为数值和运算符，并存储在队列中。
●运算符优先级处理：使用栈来存储运算符并进行优先级处理，确保正确的运算顺序。
●括号匹配：使用栈来匹配括号，以确保括号内的表达式可以正确计算。
●表达式计算：使用队列中的数值和运算符进行计算，并得出最终结果。
5.界面设计计算器可以有一个简单的用户界面，包括一个文本框用于输入表达式和一个按钮用于计算。
在计算完成后，结果将显示在另一个文本框中。
6.实现步骤要实现计算器，可以按照以下步骤进行：1.设计数据结构：确定使用的数据结构，包括栈和队列。
2.实现表达式解析：编写代码将输入的表达式解析为队列中的数值和运算符。
3.实现运算符优先级处理：编写代码使用栈来处理运算符的优先级。
4.实现括号匹配：编写代码使用栈来匹配括号。
5.实现表达式计算：编写代码使用队列中的数据进行计算并得出结果。
6.设计界面：创建用户界面，包括输入表达式的文本框、计算按钮和显示结果的文本框。
7.组合功能：将各个模块结合起来，实现完整的计算器功能。
7.附件本文档不涉及附件。
8.法律名词及注释本文档不涉及法律名词及注释。
数据结构课程设计计算器
数据结构课程设计 计算器一、课程目标知识目标：1. 让学生掌握计算器的基本数据结构原理，包括栈、队列等在计算器中的应用。
2. 使学生理解表达式求值的中缀转后缀方法，并能够运用数据结构实现转换过程。
3. 让学生掌握利用数据结构进行有效计算的过程，如利用栈进行算术表达式的求值。
技能目标：1. 培养学生运用数据结构解决实际问题的能力，如设计并实现一个简单的计算器程序。
2. 培养学生通过编程实践，加深对计算器内部处理机制的理解，提高编程技能。
3. 培养学生团队合作能力，通过小组合作完成课程设计任务。
情感态度价值观目标：1. 培养学生对计算机科学和编程的兴趣，激发其探究计算器内部原理的欲望。
2. 培养学生严谨的科学态度，注重细节，追求程序的正确性和效率。
3. 培养学生面对问题时，能够积极寻求解决方案，勇于克服困难的精神。
课程性质分析：本课程设计为高年级的数据结构课程实践环节，旨在通过实际案例让学生将理论知识与实际应用相结合，加深对数据结构原理的理解。
学生特点分析：学生已经具备了一定的编程基础和数理逻辑思维能力，能够理解较为复杂的数据结构，并具备一定的程序设计能力。
教学要求：1. 教师应引导学生主动探究，培养学生自主学习能力。
2. 教学过程中注重理论与实践相结合，强调动手实践能力。
3. 注重培养学生的团队协作能力和沟通能力，提高其综合素质。
二、教学内容1. 计算器的基本数据结构原理：- 栈的概念、原理及应用- 队列的概念、原理及应用2. 表达式求值：- 中缀表达式与后缀表达式的转换方法- 利用栈进行后缀表达式的求值3. 计算器程序设计：- 设计计算器程序的需求分析- 计算器程序的数据结构设计- 计算器程序的核心算法实现4. 课程实践：- 按照教学进度，分阶段完成计算器程序的设计与实现- 小组合作，进行程序调试与优化- 提交课程设计报告，分享学习成果教学内容安排与进度：1. 第1周：学习计算器基本数据结构原理，了解栈、队列的应用场景2. 第2周：学习表达式求值方法，掌握中缀转后缀及后缀求值算法3. 第3周：进行计算器程序设计，完成需求分析、数据结构设计和核心算法实现4. 第4周：课程实践，小组合作完成计算器程序的设计与实现，进行调试与优化5. 第5周：提交课程设计报告，进行成果分享和总结教材章节关联：本教学内容与教材中“数据结构”、“算法设计与分析”章节相关，结合实际案例，引导学生将所学知识应用于计算器程序设计中。
数据结构课程设计 模拟计算器程序
数据结构课程设计题目名称：模拟计算器程序计算机科学与技术学院课程设计任务书一、设计任务设计一个模拟计算器的程序二、设计要求1、要求对包含加、减、乘、除、括号运算符及SQR和ABS函数的任意整型表达式进行求解2、程序基本功能要求实现完整，并有简单的验证。
3、设计报告要求格式规范，符合学校课程设计报告要求。
4、报告中流程图要求描述规范，算法设计清楚正确。
三、设计期限2018年3月5日到2018年3月30日前言利用本学期所学的《数据结构》课程，运用相关知识，查阅相关资料，编写C语言程序，设计一个简单计算器，要求编写的简单计算器能够模拟windows系统的计算器，用户能够用键盘输入相关数据，要求对包含加、减、乘、除、括号运算符及SQR和ABS函数的任意整型表达式进行求解，并且在程序运行过程中能够正常的退出程序。
这个程序实际上就是对一个表达式进行计算。
而一个算术表达式中包含各种运算符，每个运算符的等级可能会不同，这就成了本程序需要解决的一个主要的问题之一了。
另外计算器中需要有各种数学函数，比如：abs sqrt sin cos tan等，如何对这些函数进行处理，也是本程序能成功的一个关键。
还有一个问题就是如何处理操作符和操作数之间的关系也是一个要点。
例如：1+2*(3-2/1)，经过怎么样的变换和处理能得出结果５。
数据的输入这里应该要用字符，然后通过字符和整形之间的关系进行转换即可，这样处理的话，就方便很多了。
在计算器程序运行中，输入数据时如果遇到输入错误的情况，能够能过键盘上的退格键进行删除，并且重新输入正确的数据。
在数据输入完成后，如果需要放弃本次计算操作，可以利用程序中设置好的按键进行清零，并为下一次运算作准备。
本课程设计主要解决的是传统计算器中，不能对表达式进行运算的问题，通过制作该计算器模拟程序，可以做到快速的求解表达式的值，并且能够判定用户输入的表达式是否合法。
该模拟计算器的核心部分就在用户输入的中缀表达式的转化，程序中用到了“栈”的后进先出的基本性质。
数据结构课程设计-计算器
数据结构课程设计-计算器数据结构课程设计计算器在计算机科学的学习中，数据结构是一门重要的基础课程。
通过这门课程的学习，我们能够深入理解和掌握如何有效地组织和管理数据，以提高程序的运行效率和性能。
本次课程设计的任务是开发一个简单的计算器程序，通过运用所学的数据结构知识，实现基本的算术运算功能。
一、需求分析首先，我们需要明确计算器程序的功能需求。
这个计算器应该能够支持常见的四则运算，即加法、减法、乘法和除法。
用户可以通过输入表达式，例如“2 ＋3”、“5 2”、“3 4”、“8 ／2”等，程序能够正确计算并输出结果。
此外，为了提高用户体验，计算器还应该能够处理错误输入，例如输入的表达式不符合语法规则或者除数为 0 等情况，并给出相应的错误提示信息。
二、数据结构选择为了实现上述功能，我们需要选择合适的数据结构来存储和处理输入的表达式。
在这个计算器程序中，我们可以使用栈这种数据结构。
栈是一种后进先出（Last In First Out，LIFO）的数据结构，非常适合处理表达式的计算。
我们可以创建两个栈，一个用于存储操作数，另一个用于存储操作符。
当用户输入一个表达式时，我们按照从左到右的顺序逐个字符进行处理。
如果是数字，则将其转换为整数并压入操作数栈；如果是操作符，则将其压入操作符栈。
在计算过程中，我们从操作符栈中取出操作符，从操作数栈中取出相应数量的操作数进行计算，将计算结果压回操作数栈。
三、算法设计1、表达式解析算法从左到右扫描表达式。
如果遇到数字，将其作为一个整数提取出来，并压入操作数栈。
如果遇到操作符（＋、、、／），则将其压入操作符栈。
如果遇到左括号“（”，则将其压入操作符栈。
如果遇到右括号“）”，则从操作符栈中弹出操作符，从操作数栈中弹出操作数，进行计算，直到遇到左括号为止。
2、计算算法当操作符栈不为空时，从操作符栈中弹出一个操作符。
根据操作符的类型，从操作数栈中弹出相应数量的操作数。
进行计算，并将结果压回操作数栈。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计报告实验一：计算器设计要求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中只有一个数值，则此数值为计算的最终结果，否则说明输入有误。