数据结构课程设计图的遍历和生成树求解.docx

数据结构课程设计图的遍历和生成树求解.docx

《数据结构课程设计图的遍历和生成树求解.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计图的遍历和生成树求解.docx（34页珍藏版）》请在冰豆网上搜索。

数据结构课程设计图的遍历和生成树求解

数学与计算机学院

课程设计说明书

课程名称:

数据结构与算法课程设计

课程代码:

6014389

题目:

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

年级/专业/班:

学生姓名:

学　　号:

开始时间:

2012年12月09日

完成时间:

2012年12月26日

课程设计成绩：

学习态度及平时成绩（30）

技术水平与实际能力（20）

创新（5）

说明书（计算书、图纸、分析报告）撰写质量（45）

总分（100）

指导教师签名：

年月日

摘要

《数据结构》课程主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。

进行数据结构课程设计要达到以下目的：

⏹了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；

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

⏹提高综合运用所学的理论知识和方法独立分析和解决问题的能力；

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

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

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

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

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

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

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

关键词：

计算机；图；算法。

引言

很多涉及图的操作的算法都是以图的遍历操作为基础，通过遍历的演示，方便在学习中更好的理解突地遍历的过程。

通过对图的深度优先遍历和广度优先遍历的演示，分别两种遍历的不同与其优缺点。

我们在对一些问题进行求解时，会发现有些问题很难找到规律，或者根本无规律可寻。

对于这样的问题，可以利用计算机运算速度快的特点，先搜索查找所有可能出现的情况，再根据题目条件从所有可能的情况中，删除那些不符合条件的解。

在深度优先搜索算法中，是深度越大的结点越先得到扩展。

如果在搜索中把算法改为按结点的层次进行搜索，本层的结点没有搜索处理完时，不能对下层结点进行处理，即深度越小的结点越先得到扩展，也就是说先产生的结点先得以扩展处理，这种搜索算法称为广度优先搜索法。

很多问题都可以用广度优先搜索进行处理、如翻币问题、最短路径问题等。

在计算机中，有多种方法存储图的信息，由于图的结构复杂，使用广泛，一般应根据实际的应用，选择适合的表示方法。

常用的图的存储结构有邻接矩阵、邻接多重表和邻接表。

在实际问题当中，经常遇到这类问题，为新建的某个机构进行选址、道路交通路线、如何走完所有路线、旅游线路等一系列问题都涉及到图的知识。

图是一种复杂的非线性数据结构，一个图G（Grah）由两个集合V和E构成。

图存在两种遍历方式：

深度优先遍历和广度优先遍历。

广度优先遍历基本思路是假设从图中某顶点U出发，在访问了顶点U之后依次访问U的各个未访问的领接点，然后分别从这些领接点出发依次访问他们的领接点，并使先访问的顶点的领接点先于后访问的顶点被访问。

直至所有领接点被访问到。

深度优先的基本思路是从某个顶点出发访问此顶点，然后依次从V的未被访问的领接点出发深度优先检索图。

直至图中所有顶点都被访问到。

PRIM算法—KRUSKAL算法，可以对图形进行最小生成树的求解。

树型结构是一种非线性结构，它用于描述数据元素之间层次关系，如人类社会的族谱等，树型结构的应用非常广泛，磁盘文件目录结构就是一个典型的例子。

1需求分析

1.1任务与分析

问题描述：

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

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

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

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

基本功能

1）先任意创建一个图；

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

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

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

输入输出

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

1.2测试数据

根据提示，输入所对应的功能，输入相关数据进行测试。

2概要设计

设计思路：

a.图的邻接矩阵存储：

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

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

b.图的邻接表存储：

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

c.图的广度优先遍历：

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

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

d.图的深度优先遍历：

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

e.图的连通分量：

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

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

2.1ADT描述

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;

2.2程序模块结构

软件结构设计：

函数名

返回值类型

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

2.2.1　结构体定义

邻接矩阵定义:

typedefstructArcCell

typedefstruct

邻接表的定义:

typedefstructArcNode//弧结点

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

typedefstruct//图的定义

队列定义:

typedefstructQNode

2.3　各功能模块

邻接矩阵存储：

intcreatMGraph_L（MGraph_L&G）

邻接矩阵的输出：

voidljjzprint（MGraph_LG）

用邻接表存储图：

intcreatadj（ALGraph&gra,MGraph_LG）

邻接表输出：

voidadjprint（ALGraphgra,MGraph_LG）

初始化队列：

StatusInitQueue（LinkQueue&Q）

入队：

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

出队：

StatusDeQueue（LinkQueue&Q,QElemType&e）//出队，若队列不空，则删除Q的队头元素，用e返回，并返回真，否则假

判断队为空：

StatusQueueEmpty（LinkQueueQ

广度优先遍历：

voidBFSTraverse（ALGraphgra）

深度优先遍历：

intDFS（ALGraphgra,inti）

连通分量：

intDFSTraverse_fen（ALGraphgra）

3详细设计

主函数：

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<<"若该图为非强连通图（含有多个连通分量）时，最小生成树不存在"<

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<<"该图为非强连通图（含有多个连通分量），最小生成树不存在"<

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

{

cin>>G.vexs[i];

}

for（i=0;i

for（j=0;j

{

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

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

}

for（intk=0;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）;

}