数据结构课设 表达式求值.docx
《数据结构课设 表达式求值.docx》由会员分享，可在线阅读，更多相关《数据结构课设 表达式求值.docx（29页珍藏版）》请在冰豆网上搜索。
数据结构课设表达式求值
《计算表达式》课程设计报告
标题：
计算表达式
单位：
报告人：
指导教师：
编程环境：
VC6
时间：
2011年12月20日
一、设计要求
对于输入的一个中缀表达式，判断表达式是否合法。
如果合法，把中缀表达式转换成一棵二叉树，然后通过后根遍历计算表达式的值，输出运算结果。
合法表达式不能为空，可以出现在表达式中的字符有：
*运算符“+”、“-”、“*”、“／”；
*左右括号“（”、“）”；
*整数（可以是多位的）；
*空格符和制表符。
例如：
表达式为“20+（3*（4+46）-6）／2-134”将得到结果-42。
数据结构采用二叉树的链接表示。
二、题目分析
由设计要求可以确定程序的几大模块，读入源程序
（1）读入中缀表达式
（2）从中缀表达式ex（长度为n）创建二叉树
（3）后根遍历计算表达式的值
（4）输出运算结果
进一步确定几个子程序及其相互之间的调用关系为：
三．流程图
四．全局变量与子程序功能说明
（1）intextoBinTree
（PBinTreepbtree,constchar*ex,intn）
从中缀表达式ex（长度为n）创建二叉树。
若是一个合法的表达式，则返回TRUE，且算法结束时*pbtree存放二叉树的根节点的地址；否则返回FALSE
（2）intcal（BinTreebtree,int*presult）
计算二叉树btree所代表的表达式的值。
若是一个合法的表达式，则返回TRUE，且算法结束时*presult中存放计算结果；否则，返回FALSE.
（3）voiddelete_BTree（PBinTreeptree）
{
BinTreetemp=（*ptree）;
if（temp==NULL）return;
delete_BTree（&（temp->llink））;
delete_BTree（&（temp->rlink））;
free（temp）;
}
作用为，当输入的程序有误时，或者一段表达式已经运算结束时清除储存空间，为下一段表达式的计算作准备。
（4）voidgetline（char*line,intlimit）
{
charc;
inti=0;
while（i=EOF&&c!
='\n'）
line[i++]=c;
line[i]='\0';
}
从标准输入中读入一行，作为字符串line，作用为程序执行的第一步将所输入的表达式读入
五．源程序（附）
六．测试
（1）输入，编译，链接程序
（2）执行程序
（3）输入表达式
20+（3*（4+46）-6）／2-134
（4）输入Y继续执行运算表达式
（5）输入N结束运算程序
七．参考文献说明
数据结构（C语言版）严蔚敏清华大学出版社
数据结构课程设计苏仕华机械工业出版社
数据结构实验与实训教程邓文华清华大学出版社
C程序设计（第二版）谭浩强清华大学出版社
《交通咨询系统设计》课程设计报告
1.设计要求
设计一个交通咨询系统能让旅客咨询从任意一个城市顶点到另一城市顶点之间的最短路径或最低花费或最少时间等问题。
对于不同的咨询要求，可输入城市间的路程或所需费用。
2.题目分析
（设计思想、主要数据结构、主要代码结构、主要代码段分析）
设计共分为三个部分，
1.一是用有向图的邻接矩阵建立交通网络图的存储结构；
首先要定义交通图的存储结构。
邻接矩阵是表示图形中顶点之间相邻关系的矩阵。
一个图的邻接矩阵表示是唯一的。
除了用一个二维数组存储顶点之间相邻关系的邻接矩阵外，通常还需要用一个具有n个元素的一维数组来存储顶点信息。
2.二是是用迪杰斯特拉（Dijkstra）算法解决源点到所有点的最短路径问题；
单源最短路径问题：
即有向图（带权），我们希望找出从某个源点S∈V到G中其余个顶点的最短路径。
用迪杰斯特拉算法（按路径长度递增产生诸顶点的最短路径算法）可以求得有向图的单源最短路径。
3．三是用费罗伊德（Floyd）算法算出任意两点之间的最短路径
最短路径的解决方法：
我们可以一次吧有向网络中德没打个顶点作为源点，重复执行前面讨论的底特斯特拉算法n次，即可求出每对顶点之间的最短路径。
主要数据结构：
1.建立有向图的存储结构
2.迪杰斯特拉算法
3.费罗伊德算法
4.主框架函数的实现
3.流程图
4.全局变量与子程序功能说明
主要代码结构：
（1）voidCreateMGraph（MGraph*G,intn,inte）
建立有向图的存储结构
voidCreateMGraph（MGraph*G,intn,inte）
{//采用邻接矩阵表示法构造有向图G，n,e表示图的当前结点数和边数
inti,j,k,w;
for（i=1;i<=n;i++）//输入顶点信息
G->vexs[i]=（char）i;
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
G->arcs[i][j]=Maxint;//初始化邻接矩阵，权值为无限大
printf（"输入%d条边的i,j及w:
\n",e）;
for（k=1;k<=e;k++）{//读入e条边，建立邻接矩阵
scanf（"%d%d%d",&i,&j,&w）;//////////////////顶点i到顶点j的权值w
G->arcs[i][j]=w;//将i和j两点之间的权值赋给arcs[i][j]
}
printf（"有向图的存储结构建立完毕!
\n"）;
}
（2）voidDijkstra（MGraph*G,intv1,intn）
迪杰斯特拉算法
{
//用Dijkstra算法求有向图G的v1顶点到其他顶点v的最短路径P[v]及其权D[v]
//设G是有向图的邻接矩阵，若边不存在，则G[i][j]=Maxint、*菡枫*
//S[v]为真，当且仅当v∈s,即已求得从v1到v的最短路径
intD2[MVNum],P2[MVNum];
intv,i,w,min;
enumbooleanS[MVNum];
for（v=1;v<=n;v++）{//初始化S和D
S[v]=FALSE;//置空最短路径终点集
D2[v]=G->arcs[v1][v];//置初始的最短路径值
if（D2[v]P2[v]=v1;//v1是v的前趋（双亲）
else
P2[v]=0;//v无前趋
}
D2[v1]=0;
S[v1]=TRUE;//S集初始只有源点，源点到源点的距离为0
//开始循环，每次球得v1到某个v顶点的最短路径，并加v到S集中
for（i=2;imin=Maxint;
for（w=1;w<=n;w++）
if（!
S[w]&&D2[w]v=w;
min=D2[w];
}//更新当前最短路径及距离
S[v]=TRUE;
for（w=1;w<=n;w++）
if（!
S[w]&&（D2[v]+G->arcs[v][w]D2[w]=D2[v]+G->arcs[v][w];
P2[w]=v;
}
}
printf（"路径长度:
路径\n"）;
for（i=1;i<=n;i++）{
printf（"]",D2[i]）;
printf（"]",i）;v=P2[i];
while（v!
=0）{
printf（"<-%d",v）;
v=P2[v];
}
printf（"\n"）;
}
}
（3）voidFloyd（MGraph*G,intn）
费罗伊德算法
{
inti,j,k,v,w;
for（i=1;i<=n;i++）//设置路径长度D和路径path初值*菡枫*
for（j=1;j<=n;j++）
{
if（G->arcs[i][j]!
=Maxint）
P[i][j]=j;
else
P[i][j]=0;
D[i][j]=G->arcs[i][j];
}
for（k=1;k<=n;k++）//做k次迭代，每次均试图将顶点K扩充到点钱球得的从i到j的最短路径Pij上
{
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
{if（D[i][k]+D[k][j]D[i][j]=D[i][k]+D[k][j];//修改长度
P[i][j]=P[i][k];
//printf（"dij=%d,pij=%d\n",D[i][j],P[i][j]）;
}
}
}
}
5.源程序（附）
6.测试
调试过程（测试数据设计与测试结果分析）
1.输入源程序编译并链接
2.执行
（1）按要求输入图中的定点个数和边数n,e:
4,5
（2）i,j是图中边的顶点编号，w是边的权值
（3）按要求输入:
按enter键选择1，求单源路径，输入1（求顶点1到其它点的最短路径）
（4）
此为源点1到其它点的最短路径
然后选择2后，程序调用Floyd算法
输入源点和终点v，w：
2,3
顶点2到顶点3无路径，选择0退出。
总结
1、设计中遇到的问题及解决过程
在输入i,j,w的值时对数据的输入规则不够清楚，有向图的认识不熟悉，多看几遍实验程序了解输入数据的有向单一性。
2、设计中产生的错误及原因分析
在Floyd算法中v，w是无效引用的局部变量，将i=1错输为i=i让程序在求最短路径是发生错误
3、设计体会和收获
对于图的认识更深入了解，了解迪杰斯特拉算法和费罗伊德算法的数据结构。
7.参考文献说明
数据结构（C语言版）严蔚敏清华大学出版社
数据结构课程设计苏仕华机械工业出版社
数据结构实验与实训教程邓文华清华大学出版社
C程序设计（第二版）谭浩强清华大学出版社
（附：
交通咨询系统设计源程序）
#include
#include
#defineMVNum100//定义最大的定点数
#defineMaxint32767//初始定义两点之间的权值无限大
enumboolean{FALSE,TRUE};
typedefcharVertexType;
typedefintAdjmatrix;
typedefstruct{
VertexTypevexs[MVNum];//顶点数组，类型假定为char型
Adjmatrixarcs[MVNum][MVNum];//链接矩阵，假定为int型
}MGraph;
intD1[MVNum],P1[MVNum];
intD[MVNum][MVNum],P[MVNum][MVNum];
//定义三个函数
voidCreateMGraph（MGraph*G,intn,inte）;//建立有向图的存储结构
voidDijkstra（MGraph*G,intv1,intn）;//迪杰斯特拉算法
voidFloyd（MGraph*G,intn）;//弗洛伊德算法
////////////////////////////////////
////////////主函数//////////////////
///////////////////////////////////
voidmain（）{
MGraph*G;
intm,n,e,v,w,k;
intxz=1;
G=（MGraph*）malloc（sizeof（MGraph））;//创建一个新的结点
printf（"输入图中顶点个数（n）和边数（e）:
"）;
scanf（"%d%d",&n,&e）;
CreateMGraph（G,n,e）;//建立有向图的存储结构
while（xz!
=0）{
printf（"***********求城市之间的最短路径*************\n"）;
printf（"============================================\n"）;
printf（"1.求一个城市到所有城市的最短路径\n"）;
printf（"2.求任意的两个城市之间的最短路径\n"）;
printf（"============================================\n"）;
printf（"请选择:
1或2,选择0退出:
"）;
scanf（"%d",&xz）;
if（xz==2）{
Floyd（G,n）;//调用佛洛依德算法
printf（"输入源点（或称起点）和终点：
v,w:
"）;
scanf（"%d,%d",&v,&w）;
k=P[v][w];//k为起点v的后继顶点
if（k==0）
printf（"顶点%d到%d无路径!
\n",v,w）;
else{
printf（"从顶点%d到%d的最短路径是:
%d",v,w,v）;
while（k!
=w）{
printf（"->%d",k）;//输出终点
k=P[k][w];//继续找下一个后继顶点
}
printf（"->%d",w）;//输出终点w
printf（"路径长度:
%d\n",D[v][w]）;
}
}
else
if（xz==1）{
printf（"求单源路径,输入源点v:
"）;
scanf（"%d",&v）;
Dijkstra（G,v,n）;//调用迪杰斯特拉算法
}
}
printf（"结束求最短路径,再见!
\n"）;
}
/////////////////////////////////////////////
/////////创建有向图的存储结构////////////////
/////////////////////////////////////////////
voidCreateMGraph（MGraph*G,intn,inte）
{//采用邻接矩阵表示法构造有向图G，n,e表示图的当前结点数和边数
inti,j,k,w;
for（i=1;i<=n;i++）//输入顶点信息
G->vexs[i]=（char）i;
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
G->arcs[i][j]=Maxint;//初始化邻接矩阵，权值为无限大
printf（"输入%d条边的i,j及w:
\n",e）;
for（k=1;k<=e;k++）{//读入e条边，建立邻接矩阵
scanf（"%d%d%d",&i,&j,&w）;//////////////////顶点i到顶点j的权值w
G->arcs[i][j]=w;//将i和j两点之间的权值赋给arcs[i][j]
}
printf（"有向图的存储结构建立完毕!
\n"）;
}
/////////////////////////////////////////
///////////////迪杰斯特拉算法////////////
/////////////////////////////////////////
voidDijkstra（MGraph*G,intv1,intn）
{
//用Dijkstra算法求有向图G的v1顶点到其他顶点v的最短路径P[v]及其权D[v]
//设G是有向图的邻接矩阵，若边不存在，则G[i][j]=Maxint、*菡枫*
//S[v]为真，当且仅当v∈s,即已求得从v1到v的最短路径
intD2[MVNum],P2[MVNum];
intv,i,w,min;
enumbooleanS[MVNum];
for（v=1;v<=n;v++）{//初始化S和D
S[v]=FALSE;//置空最短路径终点集
D2[v]=G->arcs[v1][v];//置初始的最短路径值
if（D2[v]P2[v]=v1;//v1是v的前趋（双亲）
else
P2[v]=0;//v无前趋
}
D2[v1]=0;
S[v1]=TRUE;//S集初始只有源点，源点到源点的距离为0
//开始循环，每次球得v1到某个v顶点的最短路径，并加v到S集中
for（i=2;imin=Maxint;
for（w=1;w<=n;w++）
if（!
S[w]&&D2[w]v=w;
min=D2[w];
}//更新当前最短路径及距离
S[v]=TRUE;
for（w=1;w<=n;w++）
if（!
S[w]&&（D2[v]+G->arcs[v][w]D2[w]=D2[v]+G->arcs[v][w];
P2[w]=v;
}
}
printf（"路径长度:
路径\n"）;
for（i=1;i<=n;i++）{
printf（"]",D2[i]）;
printf（"]",i）;v=P2[i];
while（v!
=0）{
printf（"<-%d",v）;
v=P2[v];
}
printf（"\n"）;
}
}
///////////////////////////////////
////////////佛洛依德算法///////////
///////////////////////////////////
voidFloyd（MGraph*G,intn）
{
inti,j,k,v,w;
for（i=1;i<=n;i++）//设置路径长度D和路径path初值*菡枫*
for（j=1;j<=n;j++）
{
if（G->arcs[i][j]!
=Maxint）
P[i][j]=j;
else
P[i][j]=0;
D[i][j]=G->arcs[i][j];
}
for（k=1;k<=n;k++）//做k次迭代，每次均试图将顶点K扩充到点钱球得的从i到j的最短路径Pij上
{
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
{if（D[i][k]+D[k][j]D[i][j]=D[i][k]+D[k][j];//修改长度
P[i][j]=P[i][k];
//printf（"dij=%d,pij=%d\n",D[i][j],P[i][j]）;
}
}
}
}
（附：
表达式求值源程序）
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineMAXNUM1000
typedefintDataType;
structBinTreeNode;
typedefstructBinTreeNode*PBinTreeNode;
structBinTreeNode
{
DataTypeinfo;
PBinTreeNodellink;
PBinTreeNoderlink;
};
typedefstructBinTreeNode*BinTree;
typedefBinTree*PBinTree;
intextoBinTree（PBinTreepbtree,constchar*ex,intn）
/*从中缀表达式ex（长度为n）创建二叉树。
若是一个合法的表达式，则返回TRUE，且算法结束时*pbtree存放二叉树的根节点的地址；否则返回FALSE*/
{
charc;
intindex,i,bracket;
inthave_bracket=FALSE;/*记录表达式中是否包含括号*/
intnum,state_int,nint;
inttag1,tag2;
if（ex[0]==''||ex[0]=='\t'||ex[0]=='\n'）
returnextoBinTree（pbtree,ex+1,n-1）;/*忽略掉左边的若干空字符*/
if（ex[n-1]==''||ex[0]=='\t'||ex[0]=='\n'）
returnextoBinTree（pbtree,ex,n-1）;/*忽略掉右边的若干空字符*/
if（ex[0]=='（'&&ex[n-1]=='）'）
returnextoBinTree（pbtree,ex+1,n-2）;/*忽略掉左右的成对括号*/
bracket=0;
index=n;
for（i=n-1;i>=0;i--）/*从后向前搜索，寻找到第一个不在括号中的优先级最低的运算符*/
{
c=ex[i];
if（c=='）'）/*进入一层括号*/
{
have_bracket=TRUE;
bracket++;
}
if（c=='（'）bracket--;/*出一层括号*/
if（bracket<0）/*左右括号不相匹配，表达式非法*/
{
*pbtree=NULL;
returnFALSE;
}
if（bracket>0）continue;/*若当前位置在某层括号中，直接搜索下个位置*/
if（c=='+'||c=='-'）
if（index==n||ex[index]=='*'||ex[index]=='/'）
index=i;
if（c=='*'||c=='/'）
if（index==n）
index=i;
}
if（bracket!
=0）returnFALSE;/*左右括号不相匹配，表达式非法*/
if（index==n）/*说明这是一个只含一个数字和若干空字符的表达式，相应地创建一棵只含一个根节点的二叉树*/
{
if（have_bracket==TRUE）
{
*pbtree=NULL;
returnFALSE;
}/*不应含有括号*/
nint=0;/*nint记录表达式中含有的整数个数*/
state_int=FALSE;/*state_int记录当前读入的字符是否是数字字符*/
num=0;
for（i=0;i{
c=ex[i];
switch（c）
{
case'0':
case'1':
case'2':
case'3':
case'4':
case'5':
case'6':
case'7':
case'8':
case'9':
if（state_int==FALSE）
{
nu
升级会员 