长江大学数据结构程序设计报告.docx

长江大学数据结构程序设计报告.docx

《长江大学数据结构程序设计报告.docx》由会员分享，可在线阅读，更多相关《长江大学数据结构程序设计报告.docx（53页珍藏版）》请在冰豆网上搜索。

长江大学数据结构程序设计报告

算法与数据结构课程设计报告

系（院）：

计算机科学学院

专业班级：

计科11101

姓名：

袁斌

学号：

201103258

指导教师：

周云才

设计时间：

2013.6.17-2012.6.29

五、测试

一．设计目的

1．能根据实际问题的具体情况，结合数据结构课程中的基本理论和基本算法，分析并正确确定数据的逻辑结构，合理地选择相应的存储结构，并能设计出解决问题的有效算法。

2．提高程序设计和调试能力。

学生通过上机实习，验证自己设计的算法的正确性。

学会有效利用基本调试方法，迅速找出程序代码中的错误并且修改。

3．初步掌握软件开发过程中问题分析、系统设计、程序编码、测试等基本方法和技能。

4．训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。

5．培养根据选题需要选择学习书籍，查阅文献资料的自学能力。

二、设计任务：

设计一个基于DOS菜单的应用程序。

要利用多级菜单实现各种功能。

内容如下：

1．无向图的基本操作及应用

1创建无向图的邻接矩阵

2创建无向图的邻接表

3无向图的深度优先遍历

4无向图的广度优先遍历

2．无向网的基本操作及应用

1创建无向网的邻接矩阵

2创建无向网的邻接表

3求最小生成树

3．有向图的基本操作及应用

1创建有向图的邻接矩阵

2创建有向图的邻接表

3拓扑排序

4．有向网的基本操作及应用

1创建有向网的邻接矩阵

2创建有向网的邻接表

3关键路径

4单源最短路径

5每对顶点之间的最短路径

三、设计方案

DOS界面的主菜单

voidShowMainMenu（）

{

cout<<"\n";

cout<<"*****************图的基本操作及应用****************\n";

cout<<"*1无向图的基本操作及应用*\n";

cout<<"*2无向网的基本操作及应用*\n";

cout<<"*3有向图的基本操作及应用*\n";

cout<<"*4有向网的基本操作及应用*\n";

cout<<"*5退出*\n";

cout<<"***************************************************\n";

}

voidUDG1（）

{

do

{

cout<<"\n";

cout<<"****************无向图的基本操作及应用*************\n";

cout<<"*1创建无向图的邻接矩阵*\n";

cout<<"*2创建无向图的邻接表*\n";

cout<<"*3无向图的深度优先遍历*\n";

cout<<"*4无向图的广度优先遍历*\n";

cout<<"*5退出*\n";

cout<<"***************************************************\n";

cin>>n;

switch（n）

{

case1:

创建无向图的邻接矩阵

break;

case2:

创建无向图的邻接表

break;

case3:

无向图的深度优先遍历

break;

case4:

无向图的广度优先遍历

break;

default:

if（n!

=5）

cout<<"错误,重新输入\n";

}

}while（n!

=5）;

}

voidUDN1（）

{

do{

cout<<"\n";

cout<<"***************无向网的基本操作及应用**************\n";

cout<<"*1创建无向网的邻接矩阵*\n";

cout<<"*2创建无向网的邻接表*\n";

cout<<"*3最小生成树*\n";

cout<<"*4退出*\n";

cout<<"***************************************************\n";

cin>>n;

switch（n）

{

case1:

创建无向网的邻接矩阵

break;

case2:

创建无向网的邻接表

break;

case3:

最小生成树

break;

default:

if（n!

=4）

cout<<"错误，重新输入\n";

}

}while（n!

=4）;

}

voidDG1（）

{

do

{

cout<<"\n";

cout<<"***************有向图的基本操作及应用**************\n";

cout<<"*1创建有向图的邻接表*\n";

cout<<"*2创建有向图的邻接矩阵*\n";

cout<<"*3拓扑排序*\n";

cout<<"*4退出*\n";

cout<<"***************************************************\n";

cin>>n;

switch（n）

{

case1:

创建有向图的邻接表

break;

case2:

创建有向图的邻接矩阵

break;

case3:

拓扑排序

break;

default:

if（n!

=4）

cout<<"错误，重新输入\n";

}

}while（n!

=4）;

}

voidDN1（）

{

do

{

cout<<"\n";

cout<<"***************有向网的基本操作及应用**************\n";

cout<<"*1创建有向网的邻接矩阵*\n";

cout<<"*2创建有向网的邻接表*\n";

cout<<"*3关键路径*\n";

cout<<"*4单源最短路径*\n";

cout<<"*5每对顶点间的最短路径*\n";

cout<<"*6退出*\n";

cout<<"***************************************************\n";

cin>>n;

switch（n）

{

case1:

创建有向网的邻接矩阵

break;

case2:

创建有向网的邻接表

break;

case3:

关键路径

break;

case4:

单源最短路径

break;

case5:

每对顶点间的最短路径

print1（MK）;

break;

default:

if（n!

=6）

cout<<"错误，重新输入\n";

}

}while（n!

=6）;

}

voidmain（）

{

intn;

do

{

ShowMainMenu（）;

cin>>n;

switch（n）

{

case1:

UDG1（）;

break;

case2:

UDN1（）;

break;

case3:

DG1（）;

break;

case4:

DN1（）;

break;

default:

if（n!

=5）

cout<<"错误，重新输入";

}

}while（n!

=5）;

}

四、实现代码：

#include

#include

#include

#include

#include

usingnamespacestd;

#defineMAX_VERTEX_NUM100//最大顶点个数

#defineINFINITY10000//最大值

#defineFALSE0

#defineTRUE1

typedefintVRType;//顶点关系（表示是否相邻）

typedefcharVertexType;

typedefintInfoType;//弧相关信息

typedefenum{DG,DN,UDG,UDN}GraphKind;//{有向图，有向网，无向图，无向网}

typedefstructArcCell

{

VRTypeadj;//权值

InfoType*info;//该弧相关信息的指针

}ArcCell,AdjMartix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedefstruct

{

VertexTypevexs[MAX_VERTEX_NUM];//顶点向量

AdjMartixarcs;//邻接矩阵

intvexnum,arcnum;//图当前顶点数,弧数

GraphKindKind;//图的类型

}MGraph;

intLocateVex（MGraphG,VertexTypev）//若图中存在v，返回v在图中的位置

{

for（inti=0;i

{

if（v==G.vexs[i]）

returni;

}

return-2;

}

//***********************创建无向网的邻接矩阵**********************

intCreatMUDN（MGraph&G）//构造无向网

{

inti,j,w;

charch;

VertexTypev1,v2;

cout<<"输入顶点数,弧数：

"<

cin>>G.vexnum>>G.arcnum;//输入当前顶点数弧数是否有弧信息

cout<<"输入顶点（字符型）：

"<

for（i=0;i

{

for（j=0;j

{

G.arcs[i][j].adj=INFINITY;

G.arcs[i][j].info=NULL;

}

}

for（i=0;i

{

cout<<"输入第"<

";

cin>>ch;

G.vexs[i]=ch;

}

for（intk=0;k

{

cout<<"输入第"<

"<

cin>>v1>>v2;

cout<<"输入弧的权值：

"<

cin>>w;

if（（i=LocateVex（G,v1））!

=-2）//

if（（j=LocateVex（G,v2））!

=-2）

{

G.arcs[i][j].adj=w;//对弧写入权值

G.arcs[j][i].adj=w;//对称弧赋值

}

}

return1;

}

//***********************创建无向图的邻接矩阵**********************

voidCreatUDG（MGraph&G）

{

inti,j,k;

charch;

VertexTypev1,v2;

cout<<"输入顶点数,弧数：

"<

cin>>G.vexnum>>G.arcnum;

cout<<"输入顶点（字符型）：

"<

for（i=0;i

{

for（j=0;j

{

G.arcs[i][j].adj=0;

G.arcs[i][j].info=NULL;

}

}

for（i=0;i

{

cout<<"输入第"<

";

cin>>ch;

G.vexs[i]=ch;

}

for（k=0;k

{

cout<<"输入第"<

"<

cin>>v1>>v2;

if（（i=LocateVex（G,v1））!

=-2）//

if（（j=LocateVex（G,v2））!

=-2）

{

G.arcs[i][j].adj=1;//对弧写入权值

G.arcs[j][i].adj=1;//对称弧赋值

}

}

}

//***********************显示邻接矩阵的信息**********************

voidScanAll（MGraphG）

{

inti;

cout<<"图中顶点信息如下：

"<

for（i=0;i

cout<

cout<<"邻接矩阵如下：

"<

cout<

";

for（i=0;i

cout<

cout<

for（i=0;i

{

cout<

for（intj=0;j

cout<

cout<

}

}

typedefstructArcNode{

intadjvex;//该弧指向顶点的位置

structArcNode*nextarc;//指向下一条弧的指针

InfoType*info;//该弧相关信息的指针

}ArcNode;

typedefstructVNode

{

VertexTypedata;//顶点信息

ArcNode*firstarc;//指向第一条依附该顶点弧的指针

}VNode,AdjList[MAX_VERTEX_NUM];

typedefstruct

{

AdjListvertices;

intvexnum,arcnum;

intkind;

}ALGraph;

//************************创建无向图的邻接表**************************

voidCreatALGUDG（ALGraph&G）

{

inti,s,d;

ArcNode*p,*q;

cout<<"输入图的顶点数和边数:

";

cin>>G.vexnum>>G.arcnum;

for（i=1;i<=G.vexnum;i++）

{

cout<<"\n输入第"<

";

cin>>G.vertices[i].data;

G.vertices[i].firstarc=NULL;

}

for（i=1;i<=G.arcnum;i++）

{

cout<<"\n输入第"<

";

cin>>s>>d;

p=newArcNode;

p->adjvex=d;

p->nextarc=G.vertices[s].firstarc;

G.vertices[s].firstarc=p;//将新建的以d为信息的表结点p插入s单链表的头结点后

q=newArcNode;

q->adjvex=s;

q->nextarc=G.vertices[d].firstarc;

G.vertices[d].firstarc=q;

}

G.kind=UDG;

}

//***********************输出邻接表**********************

voidPrintALGUDG（ALGraphG）

{

ArcNode*p;

inti;

for（i=1;i<=G.vexnum;i++）

{

p=G.vertices[i].firstarc;

cout<

while（p!

=NULL）

{

cout<<"<"<adjvex].data<<">";

p=p->nextarc;

}

printf（"\n"）;

}

}

//****************************无向图的深度遍历******************************

intvisited[MAX_VERTEX_NUM];

voidDFS（ALGraphG,intv）

{

ArcNode*p;

cout<

visited[v]=1;

p=G.vertices[v].firstarc;

while（p!

=NULL）

{

if（visited[p->adjvex]==0）

DFS（G,p->adjvex）;

p=p->nextarc;

}

}

voidDFSTraverse（ALGraphG）

{

intv;

for（v=1;v<=G.vexnum;v++）

visited[v]=0;

for（v=1;v<=G.vexnum;v++）

if（visited[v]==0）

DFS（G,v）;

}

//****************************无向图的广度遍历******************************

intFirstAdjvex（ALGraphG,intv）

{

ArcNode*p;

if（p=G.vertices[v].firstarc）

returnp->adjvex;

return0;

}

intNextAdjVex（ALGraphG,intv,intw）

{

ArcNode*p;

p=G.vertices[v].firstarc;

while（p->adjvex!

=w）

p=p->nextarc;

if（p->nextarc）

returnp->nextarc->adjvex;

else

return0;

}

typedefstructQnode

{

intdata;

structQnode*next;

}Qnode;

typedefstruct

{

Qnode*front;

Qnode*rear;

}Linkqueue;

intInitqueue（Linkqueue*Q）

{

Q->front=（Qnode*）malloc（sizeof（Qnode））;

Q->rear=Q->front;

if（!

Q->front）

return0;

Q->front->next=NULL;

return1;

}

intEnqueue（Linkqueue*Q,int*e）

{

Qnode*p;

p=（Qnode*）malloc（sizeof（Qnode））;

if（!

p）

return0;

p->data=*e;

p->next=NULL;

Q->rear->next=p;

Q->rear=p;

return1;

}

voidDequeue（Linkqueue*Q,int*e）

{

Qnode*p;

if（Q->front==Q->rear）

cout<<"空"<

p=Q->front->next;

*e=p->data;

Q->front->next=p->next;

if（Q->rear==p）

Q->rear=Q->front;

free（p）;

}

voidBFSTraverse（ALGraphG）

{

intv,w,u;

for（v=1;v<=G.vexnum;++v）

visited[v]=0;

LinkqueueQ;

Initqueue（&Q）;

for（v=1;v<=G.vexnum;v++）

if（!

visited[v]）

{

visited[v]=1;cout<

Enqueue（&Q,&v）;

while（Q.front!

=Q.rear）

{

Dequeue（&Q,&u）;

for（w=FirstAdjvex（G,u）;w>=1;w=NextAdjVex（G,u,w））

if（!

visited[w]）

{

visited[w]=1;

cout<

Enqueue（&Q,&w）;

}

}

}

}

//*********************************最小生成树***************************

voidMiniSpanTree（MGraphG,VertexTypeu）

{

intk;

intj,i;

intcount=0,min;

struct

{

VertexTypeadjvex;

intlowcost;

}closedge[MAX_VERTEX_NUM];

k=LocateVex（G,u）;

for（j=0;j

if（j!

=k）

{

closedge[j].adjvex=u;

closedge[j].lowcost=G.arcs[k][j].adj;

};

closedge[k].lowcost=0;

count=1;

cout<<"最小生成树的各个边信息如下：

"<

while（count!

=G.vexnum）

{

min=1000;

for（i=0;i

{

if（closedge[i].lowcost==INFINITY||c