计本班数据结构课程设计方案研究报告《图遍历和生成树求解实现》.docx

计本班数据结构课程设计方案研究报告《图遍历和生成树求解实现》.docx

《计本班数据结构课程设计方案研究报告《图遍历和生成树求解实现》.docx》由会员分享，可在线阅读，更多相关《计本班数据结构课程设计方案研究报告《图遍历和生成树求解实现》.docx（44页珍藏版）》请在冰豆网上搜索。

计本班数据结构课程设计方案研究报告《图遍历和生成树求解实现》

安徽省巢湖学院计算机与信息工程学院

课程设计报告

课程名称《数据结构》

课题名称图的遍历和生成树求解实现

院系信息科学与工程学院

专业计算机科学与技术

班级11计本3班

学生姓名李威

学号11011183

联系方式

指导教师王占凤

2012年6月13日

一.问题描述：

1.图的遍历和生成树求解实现

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

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

生成树求解主要利用普利姆和克雷斯特算法求解最小生成树，只有强连通图才有生成树。

2.基本功能

1）先任意创建一个图；

2）图的DFS,BFS的递归和非递归算法的实现

3）最小生成树（两个算法）的实现，求连通分量的实现

4）要求用邻接矩阵、邻接表等多种结构存储实现

3.输入输出

输入数据类型为整型和字符型，输出为整型和字符

二、概要设计

1.设计思路：

a.图的邻接矩阵存储：

根据所建无向图的结点数n,建立n*n的矩阵，其中元素全是无穷大（int_max），再将边的信息存到数组中。

其中无权图的边用1表示，无边用0表示；有全图的边为权值表示，无边用∞表示。

b.图的邻接表存储：

将信息通过邻接矩阵转换到邻接表中，即将邻接矩阵的每一行都转成链表的形式将有边的结点进行存储。

c.图的广度优先遍历：

假设从图中的某个顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后再访问此邻接点的未被访问的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直至图中所有已被访问的顶点的邻接点都被访问到。

若此时图中还有未被访问的，则另选未被访问的重复以上步骤，是一个非递归过程。

d.图的深度优先遍历：

假设从图中某顶点v出发，依依次访问v的邻接顶点，然后再继续访问这个邻接点的系一个邻接点，如此重复，直至所有的点都被访问，这是个递归的过程。

e.图的连通分量：

这是对一个非强连通图的遍历，从多个结点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其连通分量的顶点集。

本程序利用的图的深度优先遍历算法。

2.数据结构设计：

ADTQueue{

数据对象：

D={ai|ai∈ElemSet,i=1,2,3……，n,n≥0}

数据关系：

R1={|ai-1,ai∈D,i=1,2,3,……，n}

基本操作：

InitQueue（&Q）

操作结果：

构造一个空队列Q。

QueueEmpty（Q）

初始条件：

Q为非空队列。

操作结果：

若Q为空队列，则返回真，否则为假。

EnQueue（&Q,e）

初始条件：

Q为非空队列。

操作结果：

插入元素e为Q的新的队尾元素。

DeQueue（&Q,e）

初始条件：

Q为非空队列。

操作结果：

删除Q的队头元素，并用e返回其值。

}ADTQueue

ADTGraph{

数据对象V：

V是具有相同特性的数据元素的集合，称为顶点集。

数据关系R：

R={VR}

VR={|v,w∈V且P（v，w）,表示从v到w的弧，

谓词P（v,w）定义了弧的意义或信息}

基本操作P：

CreatGraph（&G,V,VR）。

初始条件：

V是图的顶点集，VR是图中弧的集合。

操作结果：

按V和VR的定义构造图G。

BFSTraverse（G,visit（））。

初始条件：

图G存在，Visit是定点的应用函数。

操作结果：

对图进行广度优先遍历。

在遍历过程中对每个顶点

调用函数Visit一次且仅一次。

一旦visit（）失

败，则操作失败。

DFSTraverse（G,visit（））。

初始条件：

图G存在，Visit是定点的应用函数。

操作结果：

对图进行广度优先遍历。

在遍历过程中对每个顶点

调用函数Visit一次且仅一次。

一旦visit（）失

败，则操作失败。

DFStra_fen（G）

初始条件：

图G存在，存在图的深度优先遍历算法。

操作结果：

从多个顶点对图进行深度优先遍历，得到连通分量。

}ADTGraph。

3.软件结构设计：

函数名

返回值类型

creatMGraph_L（G）

int

creatadj（gra,G）

int

ljjzprint（G）

void

adjprint（gra,G）

void

BFSTraverse（gra）

void

DFStra（gra）

int

DFSTraverse_fen（gra）

int

MiniSpanTree_PRIM（g,G.vexnum）

int

MiniSpanTREE_KRUSCAL（G,gra）

void

三、详细设计

1.定义程序中所有用到的数据及其数据结构，及其基本操作的实现；

邻接矩阵定义:

typedefstructArcCell

{

VRTypeadj。

//VRType是顶点关系类型。

对无权图，用1或0表示相邻否；对带权图，则为权值类型

InfoType*info。

//该弧相关信息的指针

}ArcCell,AdjMatrix[max][max]。

typedefstruct

{

VertexTypevexs[max]。

//顶点向量

AdjMatrixarcs。

//邻接矩阵

intvexnum,arcnum。

//图的当前顶点数和弧数

}MGraph_L。

邻接表的定义:

typedefstructArcNode//弧结点

{

intadjvex。

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

structArcNode*nextarc。

//指向下一条弧的指针

InfoType*info。

//该弧相关信息的指针

}ArcNode。

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

{

VertexTypedata。

//顶点信息

ArcNode*firstarc。

//指向第一条依附该顶点的弧的指针

}VNode,AdjList。

typedefstruct//图的定义

{

AdjListvertices[max]。

intvexnum,arcnum。

//图的当前顶点数和弧数

}ALGraph。

队列定义:

typedefstructQNode

{

QElemTypedata。

structQNode*next。

}QNode,*QueuePtr。

typedefstruct

{

QueuePtrfront。

//队头指针

QueuePtrrear。

//队尾指针

}LinkQueue。

2．主函数和其他函数的伪码算法；

主函数：

intmain（）

{

ints。

chary='y'。

cout<<"||¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤菜单¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤||"<

cout<<"||-------------------------【0、创建一个无向图------------------------------||"<

cout<<"||-------------------------【1、显示该图的邻接矩阵--------------------------||"<

cout<<"||-------------------------【2、显示该图的邻接表----------------------------||"<

cout<<"||-------------------------【3、广度优先遍历--------------------------------||"<

cout<<"||-------------------------【4、深度优先遍历--------------------------------||"<

cout<<"||-------------------------【5、最小生成树MiniSpanTree_PRIM算法-------------||"<

cout<<"||-------------------------【6、最小生成树MiniSpanTree_KRUSCAL算法----------||"<

cout<<"||-------------------------【7、连通分量------------------------------------||"<

cout<<"||¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤||"<

while（y=='y'）

{

cout<<"请选择菜单：

"<

cin>>s。

if（s==0）

{

++o。

if（o==2）

{

n=0。

l=0。

o=0。

}

}

switch（s）

{

case0:

cout<<"创建一个无向图：

"<

MGraph_LG。

creatMGraph_L（G）。

ALGraphgra。

creatadj（gra,G）。

break。

case1:

cout<<"邻接矩阵显示如下：

"<

ljjzprint（G）。

break。

case2:

cout<<"邻接表显示如下：

"<

adjprint（gra,G）。

break。

case3:

cout<<"广度优先遍历：

"。

BFSTraverse（gra）。

cout<

break。

case4:

cout<<"深度优先遍历：

"。

DFStra（gra）。

cout<

break。

case5:

if（n==0）{cout<<"无权图没有最小生成树"。

break。

}

elseif（l>0）{cout<<"若该图为非强连通图（含有多个连通分量）时，最小生成树不存在"<

break。

}

else

{

inti,g[max][max]。

for（i=0。

i!

=G.vexnum。

++i）

for（intj=0。

j!

=G.vexnum。

++j）

g[i+1][j+1]=G.arcs[i][j].adj。

cout<<"普利姆算法:

"<

MiniSpanTree_PRIM（g,G.vexnum）。

break。

}

case6:

if（n==0）{cout<<"无权图没有最小生成树"。

break。

}

elseif（l>0）{cout<<"该图为非强连通图（含有多个连通分量），最小生成树不存在"<

break。

}

else

{

cout<<"克鲁斯卡尔算法:

"<

MiniSpanTREE_KRUSCAL（G,gra）。

break。

}

case7:

cout<<"连通分量:

"<

DFSTraverse_fen（gra）。

break。

}

cout<

y/n:

"。

cin>>y。

if（y=='n'）

break。

}

return0。

}

邻接矩阵存储：

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

{

charv1,v2。

inti,j,w。

cout<<"请输入顶点和弧的个数"<

cin>>G.vexnum>>G.arcnum。

cout<<"输入各个顶点"<

for（i=0。

i

++i）

{

cin>>G.vexs[i]。

}

for（i=0。

i

++i）

for（j=0。

j

++j）

{

G.arcs[i][j].adj=int_max。

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

}

for（intk=0。

k

++k）

{

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

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。

}

for（i=0。

i!

=G.vexnum。

++i）

for（j=0。

j!

=G.vexnum。

++j）

{

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

=1&&G.arcs[i][j].adj

}

if（n>=1）cout<<"这是一个有权图"<

elsecout<<"这是一个无权图"<

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

"<

returnG.vexnum。

}

邻接矩阵的输出：

voidljjzprint（MGraph_LG）//邻接矩阵的输出

{

inti,j。

if（n==0）

{

for（i=0。

i!

=G.vexnum。

++i）

{

for（j=0。

j!

=G.vexnum。

++j）

{

if（G.arcs[i][j].adj==int_max）{cout<<"0"<<""。

}

else{cout<

}

}

cout<

}

}

else

{

for（i=0。

i!

=G.vexnum。

++i）

{

for（j=0。

j!

=G.vexnum。

++j）

{

if（G.arcs[i][j].adj==int_max）{cout<<"∞"<<""。

}

else{cout<

}

}

cout<

}

}

}

用邻接表存储图：

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（G.arcs[i][j].adj!

=int_max）

{

arc=（ArcNode*）malloc（sizeof（ArcNode））。

arc->adjvex=j。

arc->nextarc=gra.vertices[i].firstarc。

gra.vertices[i].firstarc=arc。

}

}

gra.vexnum=G.vexnum。

gra.arcnum=G.arcnum。

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

"<

return1。

}

邻接表输出：

voidadjprint（ALGraphgra,MGraph_LG）//邻接表输出

{

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<<"->"<<"End"。

cout<

}

}

初始化队列：

StatusInitQueue（LinkQueue&Q）//初始化队列

{

Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））。

if（!

Q.front）return0。

//存储分配失败

Q.front->next=NULL。

return1。

}

入队：

StatusEnQueue（LinkQueue&Q,QElemTypee）//入队,插入元素e为Q的新的队尾元素

{

QueuePtrp。

p=（QueuePtr）malloc（sizeof（QNode））。

if（!

p）return0。

//存储分配失败

p->data=e。

p->next=NULL。

Q.rear->next=p。

Q.rear=p。

return1。

}

出队：

StatusDeQueue（LinkQueue&Q,QElemType&e）//出队，若队列不空，则删除Q的队头元素，用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。

}

判断队为空：

StatusQueueEmpty（LinkQueueQ）//判断队为空

{

if（Q.front==Q.rear）return1。

return0。

}

广度优先遍历：

voidBFSTraverse（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）。

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）

{

visited[i]=1。

intwe1。

cout<

for（we=firstadjvex（gra,gra.vertices[i]）。

we>=0。

we=nextadjvex（gra,gra.vertices[i],we））

{

we1=we。

if（visited[we]==0）

DFS（gra,we）。

we=we1。

}

return1。

}

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。

}

连通分量：

intDFSTraverse_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<

l++。

}

}

return0。

}

4.主要函数的程序流程图，实现设计中主程序和其他子模块的算法，以流程图的形式表示。

图的广度优先遍历

图的邻接矩阵存储

图的邻接表存储

图的普利姆算法求最小生成树

4、调试分析

1.实际完成的情况说明；

a.先任意创建一个图；

b.图的DFS,BFS的递归和非递归算法的实现

c.最小生成树（两个算法）的实现，求连通分量的实现

d.要求用邻接矩阵、邻接表等多种结构存储实现

支持的数据类型：

整型和字符型

2.程序的性能分析，包括时空分析；

本程序的图的遍历是以邻接表做图的存储结构，其时间复杂度为O（n+e）。

3.上机过程中出现的问题及其解决方案；

a.程序开始对无权图和有权图的邻接矩阵的输出时，无边都用的10000（无穷大int_max）表示的，这种表示和我们习惯上的0与∞的表示有差异。

所以在程序中定义了全局变量n（初值为0）,来判断创建的无向图是有权图还是无权图，n>0为有权图，此时输出的时候用∞代替10000；n=0为无权图，此时输出的时候用0代替10000.

b.程序中有的功能对某些图是不适用的，比如无权图没有最小生成树，非强连通图没有最小生成树等。

所以在程序中又新增了全局变量l,l>0时表示为非强连通图，则在求最小生成树时报错。

C.当程序先创建一个有权图后，n的值会大于1，第二次创无权图时也会被程序认为有权图，所以在程序中在定义全局变量o（初值为0）,来判断创建了几次图，当第二次创建图，即o=2时，所有全局变量在开始全归零。

4.程序中可以改进的地方说明；

当建立一个图时先得求其连通分量，从而确定全局变量l的值，从而才能判断该图是否有最小生成树。

5、