数据结构课设Word格式文档下载.docx
《数据结构课设Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构课设Word格式文档下载.docx（47页珍藏版）》请在冰豆网上搜索。
各个数据元素均含有类型相同，可唯一标识数据元素的关键字。
数据关系R：
数据元素同属一个集合。
search（s）
初始条件：
静态表已存在
查询信息
addstudent（&
增加宿舍信息
Deletstudent（&
删除宿舍信息
changestudent（&
修改宿舍信息
}ADTStaticSearchTable
2.本程序模块：
主程序模块
voidmain（）
{定义一个数组；
switch（选择）
{
case1:
查询
case2:
增加学生信息
case3:
删除学生信息
case4:
修改学生信息
case0:
退出系统
}
}
初始化模块——建立一个数组
查询模块——查询
增加信息模块——增加信息
删除信息模块——删除信息
修改信息模块——修改信息
各模块之间的调用关系如下：
修改信息模块主程序模块删除信息模块
初始查询增加信息模块
化模块模块
四_9（3）．详细设计
1.函数的调用关系反映了演示程序的层次结构
主程序
InitRoomSearchaddstudentDeletstudentchangestudent
InserSortnumberInserSortnumberInserSortnumberInserSortnumber
InserSortroomnumberInserSortroomInserSortroomInserSortroom
InserSortnameInserSortnameInserSortnameInserSortname
2.结构体声明：
typedefstruct
{
stringname;
stringnumber;
stringaddress;
}RedType;
RedTyper[MAXSIZE+1];
intlength;
}Sqlist;
3．各函数功能：
InserSortnumber（）用冒泡法对学号进行排序，并写入number.txt;
InserSortroomnumber（）用冒泡法对房号进行排序，并写入room.txt;
InserSortname（）用冒泡法对姓名进行排序，并写入name.txt;
InitRoom（）添加宿舍信息，并分别保存到changestudentchangestudentame.txt;
Search（）查询宿舍信息
Addstudent（）增加宿舍信息，并分别保存到changestudentchangestudentame.txt;
Deletstudent（）删除宿舍信息，并分别保存到changestudentchangestudentame.txt;
Changestudent（）修改宿舍信息，并分别保存到changestudentchangestudentame.txt;
4.main（）
int_tmain（intargc,_TCHAR*argv[]）
Sqlists;
intn;
cout<
<
"
输入学生人数"
endl;
cin>
>
s.length;
****************************************"
输入学生基本信息"
InitRoom（s）;
do
{cout<
*********************************学生宿舍管理系统******************************"
cout<
1.查询2.增加学生信息3.删除学生信息4.修改学生信息0.退出系统"
*****************************************************************************"
cin>
n;
switch（n）{
case1:
cout<
查询学生信息"
Search（s）;
break;
case2:
addstudent（s）;
case3:
Deletstudent（s）;
case4:
changestudent（s）;
case0:
return0;
}
}while（n）;
return0;
}
四_9（4）.调试分析
．采用数组的形式来存储学生宿舍信息
2.每个学生包括几个数据项，所以采用静态表的形式来存储
3.每次写入磁盘之前先进行冒泡插入排序
4.姓名用顺序查找，学好，宿舍用二分查找
四_9（5）.测试结果
姓名排序；
写入name.txt;
学号排序；
写入number.txt
房号排序，写入roomnymber。
Txt
题目7线索二叉树（**）
四_7（
）．设计题目要求
1.建立中序线索二叉树，并且中序遍历；
2.求中序线索二叉树上已知结点中序的前驱和后继；
四_7
（二）．需求分析和概要设计：
建立中序线索二叉树，并且中序遍历。
首先就是要建立树，再将树中序线索化。
求中序线索二叉树上已知结点中序的前驱和后继时，即是将树在遍历一遍。
也可以在遍历的过程中，将树的结点放在数组中，当然必须讲述先遍历一遍，这是用空间来换时间。
四_7（三）．详细设计：
树的结构体的声明：
typedefcharTElemtype;
typedefenumPointerTag{Link,Thread};
//设置标志：
Link为指针，Thread为线索
typedefstructBiThrNode{//树结点结构体
TElemtypedata;
structBiThrNode*lchild,*rchild;
PointerTagLTag,RTag;
}BiThrNode,*BiThrTree;
初始化树：
voidInitBiTree（BiThrTree&
T）
T=newBiThrNode;
if（!
T）exit
（1）;
T=NULL;
建立二叉树：
voidCreatBiTree（BiThrTree&
charch;
ch;
if（ch=='
@'
）T=NULL;
else
{
T=newBiThrNode;
if（!
T->
data=ch;
CreatBiTree（T->
lchild）;
rchild）;
中序线索二叉树：
voidInOrderThreading（BiThrTree&
Thrt,BiThrTree&
Thrt=newBiThrNode;
//设置头结点
Thrt）exit
（1）;
Thrt->
LTag=Link;
//头结点左边标志为指针
RTag=Thread;
//右边的为线索
rchild=Thrt;
//有孩子指向头结点本身
T）Thrt->
lchild=Thrt;
//若树根结点为空，则头结点左孩子指向头结点
{//若根结点不为空，
Thrt->
lchild=T;
//头结点左孩子指向根结点
pre=Thrt;
//设置指针pre指向头结点
InThreading（T）;
//线索化树T
pre->
RTag=Thread;
rchild=pre;
线索化树:
voidInThreading（BiThrTreep）
{
if（p）
InThreading（p->
//线索化左子树
p->
lchild）
{
p->
LTag=Thread;
lchild=pre;
}
pre->
rchild）
pre->
rchild=p;
pre=p;
中序遍历：
intInOrderTraverse_Thr（BiThrTreeT）
BiThrTreep;
inti=1;
p=T->
lchild;
while（p!
=T）
while（p->
LTag!
=Thread）
p=p->
data<
"
;
a[i]=p->
data;
i++;
length++;
RTag==Thread&
&
rchild!
rchild;
a[i]=p->
//将结点存于数组中
i++;
length++;
p=p->
returnOK;
四_7（四）．调式分析
1.采用先序输入建立二叉树
2.申请一头结点，中序线索化二叉树；
3.中序遍历线索二叉树，并用数组a[]记录中序输出的data；
4.用辅助数组a[]访问结点的前驱和后继
四_7（五）．测试结果:
题目10：
最小生成树问题（***）
四_10（
）、设计题目要求：
1．利用克鲁斯卡尔算法求网的最小生成树。
2．利用普里姆算法求网的最小生成树。
3．要求输出各条边及它们的权值。
四_10
（二）、需求分析和概要设计：
用克鲁斯卡尔和普里姆算法生成图的最小生成树。
首先要构造出图，然后将图生成树，故要使用邻接矩阵储存图。
四_10（三）、详细设计：
1.结构体声明：
typedefstructArcCell{
VRTypeadj;
//VRType是顶点的关系类型。
无权图用1或0表示相连否。
对带权图，则为权值类型。
InfoType*info;
//表示相关信息的指针
}ArcCell,AdjMatrix[MAX_VEXTEX_NUM][MAX_VEXTEX_NUM];
typedefstruct{
VertexTypevexs[MAX_VEXTEX_NUM];
//顶点向量
AdjMatrixarcs;
//邻接矩阵
intvexnum,arcnum;
//图的当前顶点数和弧度数
}MGraph;
VertexTypeadjvex;
VRTypelowcost;
}closedge;
VertexTypebegin;
VertexTypeend;
VRTypeweight;
}EdgeType;
2.函数声明：
intCreateGraph（MGraph&
G）;
//创造图
intLocateVex（MGraphG,VertexTypeu）;
//定位
intminmum（closedgeclosedge[MAX_VEXTEX_NUM]）;
//当前边中的最小边
voidMinSpanTree_PRIM（MGraphG,VertexTypeu）;
//prim算法最小生成树
voidMinSpanTree_KRUSKAL（MGraphG）;
//kruskal算法求最小生成树
4.各功能模块：
G）//创造图
{inti,j,k,w;
VertexTypev1,v2;
请输入顶点数和边数"
G.vexnum>
G.arcnum;
high=G.arcnum;
for（i=0;
i<
G.vexnum;
++i）
请输入第"
i+1<
个顶点信息"
G.vexs[i];
++i）//初始化邻接矩阵
for（j=0;
j<
++j）
G.arcs[i][j].adj=INFINITY;
G.arcs[i][j].info=NULL;
}
}
for（k=0;
k<
++k）
k+1<
条边对应的两个顶点（v1,v2）及其权值（w）"
v1>
v2>
w;
i=LocateVex（G,v1）;
j=LocateVex（G,v2）;
while（i==-1||j==-1）
顶点有误，重新输入：
edges[k+1].begin=v1;
edges[k+1].end=v2;
G.arcs[i][j].adj=w;
G.arcs[j][i].adj=w;
edges[k+1].weight=w;
intLocateVex（MGraphG,VertexTypeu）//查找
inti;
boolflage=false;
i++）
if（u==G.vexs[i]）
flage=true;
returni;
if（flage==flage）
return-1;
voidMinSpanTree_PRIM（MGraphG,VertexTypeu）//prim
intk,j,i;
closedgeclosedge[MAX_VEXTEX_NUM];
k=LocateVex（G,u）;
for（j=0;
if（j!
=k）
closedge[j].adjvex=u;
closedge[j].lowcost=G.arcs[k][j].adj;
closedge[k].lowcost=0;
for（i=1;
k=minmum（closedge）;
边：
（"
closedge[k].adjvex<
"
G.vexs[k]<
）权值：
closedge[k].lowcost<
closedge[k].lowcost=0;
for（j=1;
if（G.arcs[k][j].adj<
closedge[j].lowcost）
{
closedge[j].adjvex=G.vexs[k];
closedge[j].lowcost=G.arcs[k][j].adj;
}
voidHeapAdjust（ints,inthigh）//权值堆排序
edges[0].weight=edges[s].weight;
edges[0].begin=edges[s].begin;
edges[0].end=edges[s].end;
for（intj=2*s;
=high;
j*=2）
if（j<
high&
edges[j].weight<
edges[j+1].weight）
++j;
if（edges[0].weight>
=edges[j].weight）
edges[s].weight=edges[j].weight;
edges[s].begin=edges[j].begin;
edges[s].end=edges[j].end;
s=j;
edges[s].weight=edges[0].weight;
edges[s].begin=edges[0].begin;
edges[s].end=edges[0].end;
voidHeapSort（）
inti;
for（i=high/2;
i>
0;
--i）
HeapAdjust（i,high）;
for（i=high;
1;
edges[0].weight=edges[1].weight;
edges[0].begin=edges[1].begin;
edges[0].end=edges[1].end;
edges[1].weight=edges[i].weight;
edges[1].begin=edges[i].begin;
edges[1].end=edges[i].end;
edges[i].weight=edges[0].weight;
edges[i].begin=edges[0].begin;
edges[i].end=edges[0].end;
HeapAdjust（1,i-1）;
voidMinSpanTree_KRUSKAL（MGraphG）//kruskal
HeapSort（）;
for（intk=1;
=G.arcnum;
k++）
edges[k].weight<
intfather[MAX_VEXTEX_NUM];
inti,j,vf1,vf2;
father[i]=-1;
i=0;
j=0;
while（i<
G.arcnum&
G.vexnum-1）
vf1=Find（father,edges[i+1].begin）;
vf2=Find（father,edges[i+1].end）;
if（vf1!
=vf2）
{father[vf2]=vf1;
j++;
cout<
edges[i+1].begin<
edges[i+1].end<
edges[i+1].weight<
}
四_10（四）、调试分析
1.通信线路一旦建成，必然是双向的。
因此，构造最小生成树的网一定是无向网。
设图的顶点数不超过30个，并为简单起见，网中边的权值设成小于100的整数，可利用C语言提供的随机函数产生。
2.图的存储结构的选取应和所作操作相适应。
为了便于选择权值最小的边，此题的存储结构既不选用邻接矩阵的数组表示法，也不选用邻接表，而是以存储边（带权）的数组表示图。
3.kruskal要避免环路产生，设置标志数组。
四_10（五）、测试数
升级会员 