-
数学与计算机学院
课程设计说明书
课
程
名
称
:
p>
数据结构与算法课程设计
课
程
代
码
:
题
目
< br>:
图的遍历和最小生成树
年级
/
专业
/
班
:
2011
级软工一班
学
生
姓
名
:
学
号
:
开
始
时
间
:
2012
年
12
月
24
日
完
成
时
间
:
2012
年
1
月
3
日
课程设计成绩:
学习态度及平
技术水平与实
时成绩(
30
< br>)
际能力(
20
)
创新
(
5
)
说明书(计算书、图纸、
总
分
分析报告)
撰写质量
(
45
)
(
100
)
指导教师签名:
年
月
日
数据结构与算法课程设计
目
录
(小三黑体,居中)
引言?????????????????????????????
1
1
需求分析??????????????????????
????
2
概要设计??????
????????????????????
3
详细设计??????????????????????????
4
调试分析??????????????????????????
5
用户使用说明?????????
???????????????
6
测试结果??????????????????????????
< br>7
结论???????????????????????????
致谢?????????????????????????????
p>
参考文献?????????????????????????
??
(目录左对齐,所有的均为
1.
5
倍行距,未具体指明使用字体的均为小四宋体,
以下同)
p>
(
目录中最多放二级标题。注意看页
面的规范要求。尤其注意页眉。页眉从目录开始
)
数据结构与算法课程设计
摘
要
图是一
种比线形表和树更为复杂的数据结构。
在图形结构中,
节点之间
的关系可
以是任意的,图中任意两个数据元素之间都可能相关。本程序是采用邻接矩阵、
邻接表、
十字链表等多种结构存储来实现对图的存储。
采用邻接矩阵即为数组表
示法,
邻接表和十字链
表都是图的一种链式存储结构。
对图的遍历分别采用了广
度优先
遍历和深度优先遍历。
关键词:
图;存储结构;遍历
数据结构与算法课程设计
引
言
数据结构是计算机存储、组织数据的方式,是指相互之间存在
一种或多种
特定关系的数据元素的集合。
利用数据结构能解决许
多实际问题,
在各个方面都
有非常不错的成就。
通过本项课程设计,培养学生独立思考、综合运用所学有关相应知识的能
p>
力,使学生巩固《数据结构》课程学习的内容,掌握工程软件设计的基本方法,
强化上机动手编程能力,
闯过理论与实践相结合的难关;
为了培养学生综合运用
所学知识、独立分析和解决实际问题的能力,
培养创意识和创新能力,
使学生获
得科学研究的基础训
练。为后续各门计算机课程的学习和毕业设计打下坚实基
础。同时,可以利用这次机会来
检验自己的
c++
数据结构水平,提高自己的写作
水平,锻炼自己的动手能力。
而此次课程设计的任
务和意义在于:增强自己的动手能力,利用
VC++6.0
等专
业软件编程实现图各种遍历的算法,
以及最小生成树算法,
增强
自己的调试
程序和测试程序的能力。
1
需求分析
1.1
任务与分析
1.
由键盘向程序输入相关数据;
2.
程序处理输入数据,以十字链表
,邻接矩阵和邻接链表的形式输出;
3.
根据已建成的图,程序实现图的深度优先遍历,广度优先遍历;
4.
显示图的最小生成树,连同分量的实现;
5.
采用邻接矩阵、邻接表、十字链
表等多种结构存储来实现对图的存储。
1.2
测试数据
1.
邻接矩阵测试数据:
6 6 a
b c d e f a b 2 a e 6 a d 5 b d 4 b c 1 b f 3
2.
邻接链表测试数据:
7 8 a
b c d e f g a b a e a c a f b g b d d g c f
3.
十字链表测试数据:
4 5 3
2 2 5 4 3 99 3 4 66
2
概要设计
数据结构与算法课程设计
2.1
ADT
描述
ADT Graph {
数据对象:
V{
具有相同特征的数据元素,即
V
顶
点集
}
数据关系:
E
=
{VR}
VR={
∈
V,
表示顶点
v
和顶点
w
之
间的边;
}
基本操作:初始化空图;
输入建立图;
广度优先遍历;
深度优先遍历;
最小生成树;
}ADT Graph
2.2
程序模块结构
根据本系统对功能实现的要求,主要可以分为一下三个大的模块:
1.
邻接矩阵存储结构;
2.
邻接链表存储结构;
3.
十字链表存储结构;
其中每个模块又包涵其它相应的子功能模块。
则根据以上可以得到本系统的概要设计图
图的遍历与最小生成树
邻
接
矩
p>
阵
存
储
结
构
邻
接
链
表
存
储
< br>结
构
十
字
链
表
存
储
结
构
退
出
系
p>
统
数据结构与算法课程设计
2.3
各功能模块
(四号黑体)
2.3.1
在邻接矩阵(
AdjMWGraph
)类中
void kruscal_arc();
//
克鲁斯卡尔算法
AdjMWGraph();
//
构造函数
void CreatG(int n,int e);
//
建立一个图的邻接矩阵
void DepthF();
//
连通分量的实现
void
BoradF();
//
连通分量的实现
void
PrintOut();
//
输出图的信息
void
Prim ();
//
普里姆算法
void
kruscal_arc();
//
克鲁斯卡算法
void
DepthM();
//
深度非递归优先遍历
void
Borad(int v,int visited[]);
//
广度非递归优先遍历
void
Depth(int v,int visited[]);
//
深度递归优先遍历
2.3.2
在邻接链表(
AdjTWGraph
)类中
void Prim ();
//
普里姆算法
void
CreatG(int n,int e);
//
建立一个图的邻接表
void
kruscal_arc();
//
克鲁斯卡算法
void
DepthF()
//
连通分量的实现
void
BoradF()
//
连通分量的实现
void
PrintOut();
//
输出图的信息
void
Borad(int v,int visited[]);
//
广度非递归优先遍历
void
Depth(int v,int visited[]);
//
深度非递归优先遍历
void
DepthM(int v,int
visited[]);//
深度递归优先遍历
2.3.3
在十字链表(
Linkedmat
)类中
void Creat();
//
创建一个十字链表
void
Show();
//
输出显示十字链表
void
zh();
//
十字链表转换为邻接矩阵
void Depth(int v,int
visited[]);//
深度递归优先遍历
数据结构与算法课程设计
void
Borad(int v,int
visited[]);//
广度非递归优先遍历
void DepthF();
//
连通分量的实现
void
BoradF();
//
连通分量的实现
void
Prim ();
//
普里姆算法
void
kruscal_arc();
//
克鲁斯卡尔算法
3
详细设计
3.1
结构体定义
struct Node
{
};
struct Edge{
};
struct item
{
ElemType data;
int dest;
ElemType weight;
Edge *next;
int row;
int col;
Node *down;
Node
*right;
union
{
};
Node*next;
ElemType val;
Edge
*adj;
数据结构与算法课程设计
};
struct MinSpanTree
{ ElemType begin,end;
ElemType length;
};
3.2
初始化
(四号黑体)
3.2.1
邻接矩阵的初始化
AdjMWGraph()
最大行坐标 <
br>输入三元组 <
br>while((q->down!=h[c])&&(q->down->row <
br> <
br>权值
{ for (
int i=0; i
for
( int j=0; j
{
if( i==j ) Edge[i][j]=0;
else
Edge[i][j]=MaxWeight;
}
numE=0;
numV=0;
}
3.2.2
邻接链表的初始化
AdjTWGraph::AdjTWGraph()
{
for(int
i=0;i
{
}
Vertices[i].data=0;
Vertices[i].adj=NULL;
数据结构与算法课程设计
}
numV=0;
numE=0;
3.2.3
十字链表的初始化
LinkeDmat()
{
*hm=null;
}
3.3
图的创建
(四号黑体)
3.3.1
创建图的邻接矩阵
void AdjMWGraph::CreatG(int n,int e)
{
int vi,vj,w,i;
numE=e; numV=n;
cout<<
输入顶点的信息(整型)
:
for (i=0; i
{
cout<<
cin>>Vertices[i];
}
for
(i=0; i
{
cout<<
输入边的信息(
vi,
vj,W
)
:
cin>>vi>>vj>>w;
Edge[vi-1][vj-1]=w;
}
}
3.3.2
创建图的邻接链表
void AdjTWGraph::CreatG(int n,int e)
数据结构与算法课程设计
{
int
vi,vj;
DistT w;
numE=e;
numV=n;
cout<<
输入顶
点信息
:
for(int i=0;i
{
}
for(int j=0;j
{
cou
t<<
输入边的信息(顶点号
vi
顶点号
vj
边的权值
w
)
:
cin>>vi>>vj>>w;
if(vi<1||vi>numV||vj<1||vj>numV)
cout<<
v1
或
v2<
/p>
越
界
出
cout
<<
cin>>Vertices[i].data;
错
!
Edge *q=new
Edge;
q->dest=vj-1;
q->weight=w;
q->next=NULL; <
/p>
if(Vertices[vi-1].adj==NULL)Vertices[vi-
1].adj=q;
else{
Edge
*curr=Vertices[vi-1].adj,*pre=NULL;
while(curr!=NULL&&curr->dest
{
}
pre=curr;
curr=curr->next;
数据结构与算法课程设计
}
if(pre==NULL)
{
}
else
{
}
q->next=pre->next;
pre->next=q;
q->next=Vertices[vi-1].adj;
Vertices[vi-1].adj=q;
Edge *p=new Edge;
p->dest=vi-1;
p->weight=w;
p->next=NULL;
if(Vertices[vj
-1].adj==NULL)Vertices[vj-1].adj=p;
else{
Edge
*curr=Vertices[vj-1].adj,*pre=NULL;
while(curr!=NULL&&curr->dest
{
}
if(pre==NULL)
{
}
else
p->next=Vertices[vj-1].adj;
Vertices[vj-1].adj=p;
pre=curr;
curr=curr->next;
数据结构与算法课程设计
}
}
}
{
}
p->next=pre->next;
pre->next=p;
3.3.3
创建图的十字链表
void Linkedmat::Creat()
{
int
m,n,r,c,v,s;
Node *p,*q,*h[10];
cout<<
请输入您要创建的矩阵维数
->
cout<<
行数
:
c
in>>m;
cout<<
列数
:<
/p>
cin>>n;
s=m>n?m:n;
if(m>n) k=n;
else k=m;
p=new Node;
p->row=m;p->col=n;
hm=p;
h[0]=p;
for(int
i=1;i<=s;i++)
{
p=new Node;
p->row=0;p->col=0;
h[i]=p;
数据结构与算法课程设计
}
p->right=p;
p->down=p;
h[i-1]->next=p;
h[s]->next=hm;
cout<
注意
:
cout<<
:
cout<<
最大列
坐标
:
cout<<
三元组最多个数<
/p>
:
cout<<
若输入不在此范围内的数
据将丢失
!
int t;
cout<
<
输入非零元素的个数
t=?
cout
<<
请输入三元组的格式(以空格分开)
:r
c
v
(回车)
for(int j=0;j
{
}
cout<<
:
cin>>r>>c>>v;
p=new Node;
p->row=r;
p->col=c;
p->val=v;
q=h[r];
while((q->right!=h[r
])&&(q->right->col
p->right=q->right;
q->right=p;
q=h[c];
p->down=q->down;q->down=p;
数据结构与算法课程设计
}
3.4
图的广度优先遍历
(四号黑体)
p>
3.4.1
图的邻接矩阵的广度优先遍历
void AdjMWGraph::Borad(int v,int
visited[])
{
SqQueue
cout<
顶点
权值
visited[v]=1;
e(v);
while(!y())
{
v=e();
for(int col=0;col
if(Edge[v][col]>0&&Edge[v]
[col]
{
c
out<
顶点
权值
p>
visited[col]=1;
e(col);
}
}
}
3.4.2
图的邻接链表的广度优先遍历
void AdjTWGraph::Borad(int v,int
visited[])
{
int vj;
Edge *p;
SqQueue
cout<<
顶点
数据结构与算法课程设计
}
visited[v]=1;
e(v);
while(!y())
{
}
cout<
v=e();
p=Vertices[v].adj;
while(p!=NULL)
{
}
vj=p->dest;
if(visited[vj]==0)
{
}
p=p->next;
cout<<
顶点
权值
visited[vj]=1;
e(vj);
3.5
图的深度优先遍历
(四号黑体)
p>
3.5.1
图的邻接矩阵的深度递归优先遍历
void AdjMWGraph::Depth(int v,int
visited[])
{
co
ut<<
顶点
权值
visited[v]=1;
for(int
col=0;col
{
if(Edge[v][col]==0||Edge[v][col]==MaxW
eight)continue;
数据结构与算法课程设计
}
}
if(!visited[col])Depth(col,visited);
3.
5.2
图的邻接矩阵的深度非递归优先遍历
void AdjMWGraph::DepthM()
{
int i,j,k,m;
cout<<
顶点
权值
for(m=0;m
{
i=0;
for(j=0;;)
{
j=j%numV;
if(Edge[i][j]!=0)
{
Edge[i][j]=0;
Edge[j][i]=0;
if(Edge[j][j]==0)
{
for(k=0;k
{
}
if(k==numV)
break;
if(Edge[j][k]==0)
continue;
else
break;
数据结构与算法课程设计
}
}
}
}
}
}
else
cout<<
顶点
权值
i=j;
j++;
if(Edge[i][j]==0)
{
}
if(k==numV)
break;
for(k=0;k
{
if(Edge[i][k]==0)
continue;
else
break;
else
j++;
3.5.3
图的邻接链表的深度递归优先遍历
void AdjTWGraph::DepthM(int v,int
visited[])
{int vj;
Edge
*p;
cout<<
顶点
权值
visited[v]=1;
数据结构与算法课程设计
p=Vertices[v].adj;
while(p!=NULL)
{
}
}
vj=p->dest;
if(visited[vj]==0)
DepthM(vj,visited);
p=p->next;
3.5.4
图的邻接链表的深度非递归优先遍历
void AdjTWGraph::Depth(int v,int
visited[])
{
int vj;
Edge *p;
SqQueue
e(v);
while(!y())
{
v=e();
cout<<
顶点
权值
visited[v]=1;
p=Vertices[v].adj;
while(p!=NULL) {
vj=p->dest;
if(visited[vj]==0)
e(vj);
p=p->next;
}
}
}
3.6
最小生成树的实现
(四号黑体)
数据结构与算法课程设计
3.6.1
普利姆算法
void AdjMWGraph::Prim ()
{
int n=numV,m,v,j,d;
MinSpanTree e, mintree[MaxVertices];
for (j=1; j
{
mintree[j-1].begin=1;
mintree[j-1].end=j+1;
mintree[j-1].length=Edge[0][j];
}
for (int k=0; k
{
int
min=MaxWeight;
for (j=k; j
if (mintree[j].length
e=mintree[m]; mintree[m]=mintree[k];
mintree[k]=e;
v=mintree[k].end;
for (j=k+1; j
tree[n-1]
{
d=Edge[v-1][mintree[j].end-1];
if (d
{
mintree[j].length=d;
mintree[j].begin=v;
}
}
}
数据结构与算法课程设计
for
(j=0;j
}
cout<<
起点:
终点:
mintree[
j].end<<
权值:
3.6.2<
/p>
克鲁斯卡尔算法
void
AdjMWGraph::kruscal_arc()
{
MinSpanTree mintree[20];
int i,j,k=0;
for(i=0;i
for(j=i;j
{
if(Edge[i][j]!=10000)
{
mintree[k].begin=i;
mintree[k].end=j;
mintree[k].length=Edge[i][j];
k++;
}
}
int
x,y,m,n;
int buf,edf;
for(i=0;i
acrvisited[i]=0;
for(j=0;j
{
m=10000;
for(i=0;i
数据结构与算法课程设计
{
if(mintree[i].length
{
m=mintree[i].length;
x=mintree[i].begin;
y=mintree[i].end;
n=i;
}
}
buf=find(acrvisited,x);
edf=find(acrvisited,y);
mintree[n].length=10000;
if(buf!=edf)
{
acrvisited[buf]=edf;
cout<<
cout<
}
}
}
3.7
图的连通分量的实现
(四号黑体)
void DepthF()
{
int visit[MaxVertices];
for(int
j=0;j
for(int i=0;i
if(visit[i]==0){
Depth(i,visit);
-
-
-
-
-
-
-
-
-
上一篇:疫情面前的责任与担当
下一篇:实现图的遍历算法实验报告