图的遍历和生成树求解问题的研究与实现.docx

图的遍历和生成树求解问题的研究与实现.docx

《图的遍历和生成树求解问题的研究与实现.docx》由会员分享，可在线阅读，更多相关《图的遍历和生成树求解问题的研究与实现.docx（27页珍藏版）》请在冰豆网上搜索。

图的遍历和生成树求解问题的研究与实现

数据结构课程设计

设计说明书

图的遍历和生成树求解问题的研究与实现

学生姓名

秦洁

学号

0621024014

班级

信管061

成绩

指导教师

魏佳

计算机科学与技术系

2008年3月8日

数据结构课程设计评阅书

题目

图的遍历和生成树求解问题的研究与实现

学生姓名

秦洁

学号

0621024014

指导教师评语及成绩

指导教师签名：

年月日

答辩评语及成绩

答辩教师签名：

年月日

教研室意见

总成绩：

室主任签名：

年月日

课程设计任务书

2007—2008学年第一学期

专业：

信息管理与信息系统学号：

0621024014

姓名：

秦洁

课程设计名称：

数据结构课程设计

设计题目：

图的遍历和生成树求解问题的研究与实现

完成期限：

自2008年2月25日至2008年3月7日共2周

设计依据、要求及主要内容（可另加附页）：

设计依据：

数据结构算法设计

要求：

先任意创建一个图；

图的DFS,BFS的递归和非递归算法的实现最小生成树（两个算法）的实现，求连通分量的实现要求用邻接矩阵、邻接表、十字链表多种结构存储实现。

主要内容：

对创建的图采用邻接矩阵、邻接表、十字链表等多种结构存储，并完成图的DFS和BFS操作。

指导教师（签字）：

教研室主任（签字）：

批准日期：

年月日

摘要

图是一种较线形表和树更为复杂的数据结构。

在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。

本程序是采用邻接矩阵、邻接表、十字链表等多种结构存储来实现对图的存储。

采用邻接矩阵即为数组表示法，邻接表和十字链表都是图的一种链式存储结构。

对图的遍历分别采用了广度优先遍历和深度优先遍历。

关键词：

图；存储；遍历；深度；广度

目录

1课题描述……………………………………………………………………………1

2设计过程……………………………………………………………………………2

2.1设计思路……………………………………………………………………2

2.2设计流程图…………………………………………………………………3

2.3程序源代码…………………………………………………………………4

3编译运行…………………………………………………………………………17

总结…………………………………………………………………………………19

参考文献……………………………………………………………………………20

1课题描述

图是一种较线形表和树更为复杂的数据结构。

在线形表中，数据元素之间仅有线性关系，每个元素只有一个直接前驱和一个直接后继；在树形结构中，数据元素之间有着明显的层次关系，并且每一层上的数据元素可能和下一层中多个元素（即其孩子节点）相关，但只能和上一层中一个元素（即其双亲节点）相关；而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。

因此，图的应用极为广泛，特别是近年来的迅速发展，已深入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。

本程序是采用邻接矩阵、邻接表、十字链表等多种结构存储来实现对图的存储。

对图的遍历分别采用了广度优先遍历和深度优先遍历。

开发工具：

VisualC++6.0

2设计过程

本程序是采用邻接矩阵、邻接表、十字链表等多种结构存储来实现对图的存储。

对图的遍历分别采用了广度优先遍历和深度优先遍历。

2.1设计思路

这次课程设计我们主要是应用以前学习的数据结构与面向对象程序设计知识，结合起来才完成了这个程序。

因为图是一种较线形表和树更为复杂的数据结构。

在线形表中，数据元素之间仅有线性关系，每个元素只有一个直接前驱和一个直接后继，并且在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。

因此，本程序是采用邻接矩阵、邻接表、十字链表等多种结构存储来实现对图的存储。

采用邻接矩阵即为数组表示法，邻接表和十字链表都是图的一种链式存储结构。

对图的遍历分别采用了广度优先遍历和深度优先遍历。

2.2设计流程图

2.3程序源代码

#include

#include

usingnamespacestd;

#defineint_max10000

#defineinf9999

#definemax20

//…………………………………………邻接矩阵定义……………………

typedefstructArcCell

{

intadj;

char*info;

}ArcCell,AdjMatrix[20][20];

typedefstruct

{charvexs[20];

AdjMatrixarcs;

intvexnum,arcnum;//有向图的当前顶点数和弧数

}MGraph_L;

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

intlocalvex（MGraph_LG,charv）//返回V的位置

{inti=0;

while（G.vexs[i]!

=v）

{++i;

}

returni;}

intcreatMGraph_L（MGraph_L&G）//创建图用邻接矩阵表示

{charv1,v2;

inti,j,w;

cout<<"…………创建无向图…………"<

（46）不包括“（）”"<

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

for（i=0;i!

=G.vexnum;++i）

{cout<<"输入顶点"<

cin>>G.vexs[i];}

for（i=0;i!

=G.vexnum;++i）

for（j=0;j!

=G.vexnum;++j）

{G.arcs[i][j].adj=int_max;

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

}

for（intk=0;k!

=G.arcnum;++k）

{cout<<"输入一条边依附的顶点和权:

（ab3）不包括“（）”"<

cin>>v1>>v2>>w;//输入一条边依附的两点及权值

i=localvex（G,v1）;//确定顶点V1和V2在图中的位置

j=localvex（G,v2）;

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

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

}

cout<<"图G邻接矩阵创建成功！

"<

returnG.vexnum;

}

voidljjzprint（MGraph_LG）

{inti,j;

for（i=0;i!

=G.vexnum;++i）

{

for（j=0;j!

=G.vexnum;++j）

cout<

cout<

}

}

intvisited[max];//访问标记

intwe;

typedefstructarcnode//弧结点

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

structarcnode*nextarc;//弧尾相同的下一条弧

char*info;//该弧信息

}arcnode;

typedefstructvnode//邻接链表顶点头接点

{chardata;//结点信息

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

}vnode,adjlist;

typedefstruct//图的定义

{adjlistvertices[max];

intvexnum,arcnum;

intkind;

}algraph;

//…………………………………………队列定义……………………

typedefstructqnode

{intdata;

structqnode*next;

}qnode,*queueptr;

typedefstruct

{queueptrfront;

queueptrrear;

}linkqueue;

//………………………………………………………………………

typedefstructacr

{intpre;//弧的一结点

intbak;//弧另一结点

intweight;//弧的权

}edg;

intcreatadj（algraph&gra,MGraph_LG）//用邻接表存储图

{inti=0,j=0;

arcnode*arc,*tem,*p;

for（i=0;i!

=G.vexnum;++i）

{gra.vertices[i].data=G.vexs[i];

gra.vertices[i].firstarc=NULL;

}

for（i=0;i!

=G.vexnum;++i）

{for（j=0;j!

=G.vexnum;++j）

{if（gra.vertices[i].firstarc==NULL）

{if（G.arcs[i][j].adj!

=int_max&&j!

=G.vexnum）

{arc=（arcnode*）malloc（sizeof（arcnode））;

arc->adjvex=j;

gra.vertices[i].firstarc=arc;

arc->nextarc=NULL;

p=arc;

++j;

while（G.arcs[i][j].adj!

=int_max&&j!

=G.vexnum）

{tem=（arcnode*）malloc（sizeof（arcnode））;

tem->adjvex=j;

gra.vertices[i].firstarc=tem;

tem->nextarc=arc;

arc=tem;

++j;

}

--j;

}

}

else

{if（G.arcs[i][j].adj!

=int_max&&j!

=G.vexnum）

{

arc=（arcnode*）malloc（sizeof（arcnode））;

arc->adjvex=j;

p->nextarc=arc;

arc->nextarc=NULL;

p=arc;

}

}

}

}

gra.vexnum=G.vexnum;

gra.arcnum=G.arcnum;

/*for（i=0;i!

=gra.vexnum;++i）

{arcnode*p;

cout<

p=gra.vertices[i].firstarc;

while（p!

=NULL）

{cout<adjvex;

p=p->nextarc;

}

cout<

}*/

cout<<"图G邻接表创建成功！

"<

return1;

}

voidadjprint（algraphgra）

{inti;

for（i=0;i!

=gra.vexnum;++i）

{arcnode*p;

cout<

p=gra.vertices[i].firstarc;

while（p!

=NULL）

{cout<adjvex;

p=p->nextarc;

}

cout<

}

}

intfirstadjvex（algraphgra,vnodev）//返回依附顶点V的第一个点

//即以V为尾的第一个结点

{if（v.firstarc!

=NULL）

returnv.firstarc->adjvex;

}

intnextadjvex（algraphgra,vnodev,intw）//返回依附顶点V的相对于W的下一个顶点

{arcnode*p;

p=v.firstarc;

while（p!

=NULL&&p->adjvex!

=w）

{p=p->nextarc;

}

if（p->adjvex==w&&p->nextarc!

=NULL）

{p=p->nextarc;

returnp->adjvex;

}

if（p->adjvex==w&&p->nextarc==NULL）

return-10;

}

intinitqueue（linkqueue&q）//初始化队列

{q.rear=（queueptr）malloc（sizeof（qnode））;

q.front=q.rear;

if（!

q.front）

return0;

q.front->next=NULL;

return1;

}

intenqueue（linkqueue&q,inte）//入队

{queueptrp;

p=（queueptr）malloc（sizeof（qnode））;

if（!

p）

return0;

p->data=e;

p->next=NULL;

q.rear->next=p;

q.rear=p;

return1;

}

intdequeue（linkqueue&q,int&e）//出队

{queueptrp;

if（q.front==q.rear）

return0;

p=q.front->next;

e=p->data;

q.front->next=p->next;

if（q.rear==p）

q.rear=q.front;

free（p）;

return1;

}

intqueueempty（linkqueueq）//判断队为空

{if（q.front==q.rear）

return1;

return0;

}

voidbfstra（algraphgra）//广度优先遍历

{inti,e;

linkqueueq;

for（i=0;i!

=gra.vexnum;++i）

visited[i]=0;

initqueue（q）;

for（i=0;i!

=gra.vexnum;++i）

if（!

visited[i]）

{visited[i]=1;

cout<

enqueue（q,i）;

while（!

queueempty（q））

{dequeue（q,e）;

//cout<<""<

for（we=firstadjvex（gra,gra.vertices[e]）;we>=0;we=nextadjvex（gra,gra.vertices[e],we））

{if（!

visited[we]）

{

visited[we]=1;

cout<

enqueue（q,we）;

}

}

}

}

}

intdfs（algraphgra,inti）;//声明DFS

intdfstra（algraphgra）

{inti,j;

for（i=0;i!

=gra.vexnum;++i）

{visited[i]=0;

}

for（j=0;j!

=gra.vexnum;++j）

{if（visited[j]==0）

dfs（gra,j）;

}

return0;

}

intdfs（algraphgra,inti）

{visited[i]=1;

intwe1;

//cout<

cout<

//cout<

for（we=firstadjvex（gra,gra.vertices[i]）;we>=0;we=nextadjvex（gra,gra.vertices[i],we））

{

//cout<

we1=we;

//cout<

if（visited[we]==0）

//cout<<

dfs（gra,we）;//<

//cout<

we=we1;

//cout<

}

return12;

}

intbfstra_fen（algraphgra）//求连通分量

{inti,j;

for（i=0;i!

=gra.vexnum;++i）

{visited[i]=0;

}

for（j=0;j!

=gra.vexnum;++j）

{if（visited[j]==0）

{

dfs（gra,j）;

cout<

}

}

return0;

}

typedefstruct

{intadjvex;

intlowcost;

}closedge;

/*intminimum（closedge*p）;

intminispantree（MGraph_LG,charu）

{intk,j,i;

closedgeclosedge_a[20];

k=localvex（G,u）;

//cout<

for（j=0;j!

=G.vexnum;++j）

{if（j!

=k）

{closedge_a[j].adjvex=u;

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

}

for（i=1;i!

=G.vexnum;++i）

{k=minimum（closedge_a）;

cout<

cout<

closedge_a[k].lowcost=0;

for（j=0;j!

=G.vexnum;++j）

if（G.arcs[k][j].adj

{closedge_a[j].adjvex=G.vexs[k];

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

}

}

}

return0;

}

intminimum（closedge*p）

{ints=10000;

for（;p!

=NULL;++p）

{if（s>p->lowcost）

s=p->lowcost;

}

returns;

}*/

intprim（intg[][max],intn）//最小生成树PRIM算法

{intlowcost[max],prevex[max];//LOWCOST[]存储当前集合U分别到剩余结点的最短路径

//prevex[]存储最短路径在U中的结点

inti,j,k,min;

for（i=2;i<=n;i++）//n个顶点，n-1条边

{lowcost[i]=g[1][i];//初始化

prevex[i]=1;//顶点未加入到最小生成树中

}

lowcost[1]=0;//标志顶点1加入U集合

for（i=2;i<=n;i++）//形成n-1条边的生成树

{min=inf;

k=0;

for（j=2;j<=n;j++）//寻找满足边的一个顶点在U,另一个顶点在V的最小边

if（（lowcost[j]

=0））

{min=lowcost[j];

k=j;

}

printf（"（%d,%d）%d\t",prevex[k]-1,k-1,min）;

lowcost[k]=0;//顶点k加入U

for（j=2;j<=n;j++）//修改由顶点k到其他顶点边的权值

if（g[k][j]

{lowcost[j]=g[k][j];

prevex[j]=k;

}

printf（"\n"）;

}

return0;

}

intacrvisited[100];//kruscal弧标记数组

intfind（intacrvisited[],intf）

{while（acrvisited[f]>0）

f=acrvisited[f];

returnf;

}

voidkruscal_arc（MGraph_LG,algraphgra）

{edgedgs[20];

inti,j,k=0;

for（i=0;i!

=G.vexnum;++i）

for（j=i;j!

=G.vexnum;++j）

{if（G.arcs[i][j].adj!

=10000）

{edgs[k].pre=i;

edgs[k].bak=j;

edgs[k].weight=G.arcs[i][j].adj;

++k;

}

}

intx,y,m,n;

intbuf,edf;

for（i=0;i!

=gra.arcnum;++i）

acrvisited[i]=0;

for（j=0;j!

=G.arcnum;++j）

{m=10000;

for（i=0;i!

=G.arcnum;++i）

{if（edgs[i].weight

{m=edgs[i].weight;

x=edgs[i].pre;

y=edgs[i].bak;

n=i;

}

}

//cout<

//cout<

buf=find（acrvisited,x）;

edf=find（acrvisited,y）;

//cout<

edgs[n].weight=10000;

if（buf!

=edf）

{acrvisited[buf]=edf;

cout<<"（"<

cout<

}

}

}

voidmain（）

{algraphgra;

MGraph_LG;

inti,d,g[20][20];

chara='a';

d=creatMGraph_L（G）;

creatadj（gra,G）;

vnodev;

cout<

若该图为非强连通图（含