完整word版数据结构课程设计计算器.docx
《完整word版数据结构课程设计计算器.docx》由会员分享，可在线阅读，更多相关《完整word版数据结构课程设计计算器.docx（22页珍藏版）》请在冰豆网上搜索。
完整word版数据结构课程设计计算器
数据结构课程设计报告
实验一：
计算器
设计要求
1、问题描述：
设计一个计算器，可以实现计算器的简单运算，输出并检验结果的正确性，以及检验运算表达式的正确性。
2、输入：
不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、*、/、%、（、）。
具体事例如下：
3、输出：
如果表达式正确，则输出表达式的正确结果；如果表达式非法，则输出错误信息。
具体事例如下：
知识点：
堆栈、队列
实际输入输出情况：
正确的表达式
对负数的处理
表达式括号不匹配
表达式出现非法字符
表达式中操作符位置错误
求余操作符左右出现非整数
其他输入错误
数据结构与算法描述
解决问题的整体思路：
将用户输入的中缀表达式转换成后缀表达式，再利用转换后的后缀表达式进行计算得出结果。
解决本问题所需要的数据结构与算法：
用到的数据结构是堆栈。
主要算法描述如下：
A．将中缀表达式转换为后缀表达式：
1.将中缀表达式从头逐个字符扫描，在此过程中，遇到的字符有以下几种情况：
1）数字
2）小数点
3）合法操作符+-*/%
4）左括号
5）右括号
6）非法字符
2.首先为操作符初始化一个map:
string,int>priority，用于保存各个操作符的优先级，其中+-为0，*/%为1
3.对于输入的字符串from和输出的字符串to，采用以下过程：
初始化遍历器std:
:
string:
:
iteratorit=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<<"输入错误：
运算符号右边缺少运算数"<returnfalse;
}
if（（*it=='*'||*it=='/'）&&it==from.begin（））
{
cout<<"输入错误：
运算符号左边缺少运算数"<returnfalse;
}
if（（it+1）!
=from.end（）&&（*（it+1）=='+'||*（it+1）=='-'||*（it+1）=='*'||*（it+1）=='/'||*（it+1）=='%'））
{
cout<<"输入错误：
运算符号连续出现"<returnfalse;
}
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<<"输入错误：
表达式以左括号结尾"<returnfalse;
}
//若以+或者-开头，则按照正负号看待，向目标表达式中加入一个0
if（*（it+1）=='-'||*（it+1）=='+'）
{
to=to+'0';
}
if（（it+1）!
=from.end（）&&（（*（it+1）=='*'||*（it+1）=='/'||*（it+1）=='%'||*（it+1）=='）'）））
{
cout<<"输入错误：
左括号右边不能为运算符号或右括号"<returnfalse;
}
if（it!
=from.begin（）&&（*（it-1）!
='+'&&*（it-1）!
='-'&&*（it-1）!
='*'&&*（it-1）!
='/'&&*（it-1）!
='%'&&*（it-1）!
='（'））
{
cout<<"输入错误：
左括号左边不能为运算数或右括号"<returnfalse;
}
sym.push（*it）;
break;
}
5.遇到“）”时，将栈中的操作符从栈顶逐个弹出并放入后缀表达式中，直到在栈中遇到“（”，并将“（”从栈中弹出：
case'）':
{
if（（it+1）!
=from.end（）&&*（it+1）!
='+'&&*（it+1）!
='-'&&*（it+1）!
='*'&&*（it+1）!
='/'&&*（it+1）!
='%'&&*（it+1）!
='）'）
{
cout<<"输入错误：
右括号右边不能为运算数"<returnfalse;
}
if（it!
=from.begin（）&&（*（it-1）=='+'||*（it-1）=='-'||*（it-1）=='*'||*（it-1）=='/'||*（it-1）=='%'））
{
cout<<"输入错误：
右括号左边不能为运算符号"<returnfalse;
}
to=to+"";
if（sym.empty（））
{
cout<<"输入错误：
表达式以右括号开始"<returnfalse;
}
tem=sym.top（）;
while（tem!
='（'）
{
to=to+tem+"";
sym.pop（）;
if（sym.empty（））
{
cout<<"输入错误：
括号匹配有误"<returnfalse;
}
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<returnfalse;
}
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"<returnfalse;
}
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）
{
intn1=（int）d1;
intn2=（int）d2;
numstack.push（（double）（n1%n2））;
break;
}
else
{
cerr<<"输入错误：
求模操作只能作用于整数"<returnfalse;
}
}
3.直到后缀表达式扫描完并且堆栈numstack中只有一个数值，则此数值为计算的最终结果，否则说明输入有误。
分析与探讨：
1、测试结果分析：
测试结果见本篇开始的实际输入输出结果。
该计算器几乎实现了所有相关功能，包括简单计算、负数小数处理，容错，并且健壮性好，对于错误的表达式可以给出适当提示，不会导致程序崩溃。
2、算法分析
1、对于中缀表达式转换成后缀表达式：
时间复杂性为O（n）
2、对于后缀表达式的计算：
时间复杂性为O（n）
综上，该程序算法的时间复杂度为O（n）
3、算法改进
该程序存在的主要问题是命令行式的用户界面不够友好。
Windows下的用户图形界面需要MFC方面的知识，因为时间关系没有进行这方面的深入学习。
附录：
源代码
文件一.ExpressionHandler.h
#include
#include
#include
#include
#include
usingnamespacestd;
classExpressionHandler{
public:
ExpressionHandler（stringexp）{
this->exp=exp;
}
boolinfixtoprofix（string&exp）;
booldoprofix（stringprofix,double&result）;
private:
stringexp;
};
文件二.ExpressionHandler.cpp
//CodedByCS_Zhanglin
#include"ExpressionHandler.h"
boolExpressionHandler:
:
infixtoprofix（string&exp）{
stringfrom=this->exp;
stringto="";
stacksym;
mappri;
chartem;
pri['+']=1;
pri['-']=1;
pri['*']=2;
pri['/']=2;
pri['%']=2;
string:
:
iteratorit=from.begin（）;
if（*it=='+'||*it=='-'）to+='0';
while（it!
=from.end（））{
//cout<<1<switch（*it）
{
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;
}
case'+':
case'-':
case'*':
case'/':
case'%':
{
if（（it+1）==from.end（））
{
cout<<"输入错误：
运算符号右边缺少运算数"<returnfalse;
}
if（（*it=='*'||*it=='/'）&&it==from.begin（））
{
cout<<"输入错误：
运算符号左边缺少运算数"<returnfalse;
}
if（（it+1）!
=from.end（）&&（*（it+1）=='+'||*（it+1）=='-'||*（it+1）=='*'||*（it+1）=='/'||*（it+1）=='%'））
{
cout<<"输入错误：
运算符号连续出现"<returnfalse;
}
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;
}
case'（':
{
if（（it+1）==from.end（））
{
cout<<"输入错误：
表达式以左括号结尾"<returnfalse;
}
if（*（it+1）=='-'||*（it+1）=='+'）
{
to=to+'0';
}
if（（it+1）!
=from.end（）&&（（*（it+1）=='*'||*（it+1）=='/'||*（it+1）=='%'||*（it+1）=='）'）））
{
cout<<"输入错误：
左括号右边不能为运算符号或右括号"<returnfalse;
}
if（it!
=from.begin（）&&（*（it-1）!
='+'&&*（it-1）!
='-'&&*（it-1）!
='*'&&*（it-1）!
='/'&&*（it-1）!
='%'&&*（it-1）!
='（'））
{
cout<<"输入错误：
左括号左边不能为运算数或右括号"<returnfalse;
}
sym.push（*it）;
break;
}
case'）':
{
if（（it+1）!
=from.end（）&&*（it+1）!
='+'&&*（it+1）!
='-'&&*（it+1）!
='*'&&*（it+1）!
='/'&&*（it+1）!
='%'&&*（it+1）!
='）'）
{
cout<<"输入错误：
右括号右边不能为运算数"<returnfalse;
}
if（it!
=from.begin（）&&（*（it-1）=='+'||*（it-1）=='-'||*（it-1）=='*'||*（it-1）=='/'||*（it-1）=='%'））
{
cout<<"输入错误：
右括号左边不能为运算符号"<returnfalse;
}
to=to+"";
if（sym.empty（））
{
cout<<"输入错误：
表达式以右括号开始"<returnfalse;
}
tem=sym.top（）;
while（tem!
='（'）
{
to=to+tem+"";
sym.pop（）;
if（sym.empty（））
{
cout<<"输入错误：
括号匹配有误"<returnfalse;
}
tem=sym.top（）;
}
sym.pop（）;
break;
}
default:
{
cout<<"输入错误：
未知符号"<returnfalse;
}
}
++it;
}
if（!
sym.empty（））
{
to=to+"";
tem=sym.top（）;
while（!
sym.empty（））
{
if（tem=='（'）
{
cout<<"输入错误：
括号匹配有误"<returnfalse;
}
to=to+tem+"";
sym.pop（）;
if（sym.empty（））break;
tem=sym.top（）;
}
}
exp=to;
returntrue;
}
boolExpressionHandler:
:
doprofix（stringprofix,double&result）
{
stringnumtemp;
stacknumstack;
stringstreamstrm;
doubled,d1,d2;
for（string:
:
iteratorit=profix.begin（）;it!
=profix.end（）;++it）
{
switch（*it）
{
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<returnfalse;
}
strm.str（numtemp）;
strm>>d;
numstack.push（d）;
numtemp="";
strm.str（""）;
strm.clear（）;
break;
}
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（）;
d1=numstack.top（）;
numstack.pop（）;
numstack.push（d1*d2）;
break;
}
case'/':
{
d2=numstack.top（）;
升级会员 