图的邻接矩阵存储及遍历

合集下载

图的遍历算法

图的遍历算法

1图的遍历问题在实践中常常遇到这样的问题:给定n个点,从任一点出发对所有的点访问一次并且只访问一次。

如果用图中的顶点表示这些点,图中的边表示可能的连接,那么这个问题就可以表示成图的遍历问题,即从某个顶点出发,沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问。

图的遍历操作和树的遍历操作功能相似,是图的一种基本操作,图的许多其它操作都是建立在遍历操作的基础上。

由于图结构本身的复杂性,所以图的遍历操作也比较复杂,主要表现在以下几个方面:(1) 在图结构中,没有一个确定的首结点,图中任意一个顶点都可以作为第一个被访问的结点。

(2) 在非连通图中,从一个顶点出发,只能够访问它所在的连通分量上的所有顶点,因此,还需要考虑如何选取下一个出发点以访问图中其余的连通分量。

(3) 在图结构中,如果有回路存在,那么一个顶点被访问后,有可能沿回路又回到该顶点。

⑷在图结构中,一个顶点可以和其它多个顶点相连,当这样的顶点访问过后,存在如何选取下一个要访问的顶点的问题。

基于以上分析,图的遍历方法目前有深度优先搜索(DFS)和广度优先搜索(BFS)两种算法。

下面将介绍两种算法的实现思路,分析算法效率并编程实现。

1.1深度优先搜索算法深度优先搜索算法是树的先根遍历的推广,它的实现思想是:从图G的某个顶点V o出发,访问V o,然后选择一个与V o相邻且没被访问过的顶点V i访问,再从V i出发选择一个与V i相邻且未被访问的顶点V j进行访问,依次继续。

如果当前被访问过的顶点的所有邻接顶点都已被访问,贝U退回已被访问的顶点序列中最后一个拥有未被访问的相邻顶点的顶点W,从W出发按同样的方法向前遍历,直到图中所有顶点都被访问。

其递归算法如下:Boolean visited[MAX_VERTEX_NUM]; // 访问标志数组Status (*VisitFunc)(int v); //VisitFunc是访问函数,对图的每个顶点调用该函数void DFSTraverse (Graph G Status(*Visit)(i nt v)){VisitF unc = Visit;for(v=0; vvG.vex num; ++v)visited[v] = FALSE; //访问标志数组初始化for(v=0; v<G .vex num; ++v)if(!visited[v])DFS(G v); //对尚未访问的顶点调用DFS}void DFS(Graph G int v){ //从第v个顶点出发递归地深度优先遍历图Gvisited[v]=TRUE; VisitFunc(v); // 访问第v 个顶点for(w=FirstAdjVex(G ,v); w>=0;w=NextAdjVex(G ,v,w))//FirstAdjVex返回v的第一个邻接顶点,若顶点在G中没有邻接顶点,则返回空(0)。

数据结构-实验6图的存储和遍历

数据结构-实验6图的存储和遍历

实验6.1实现图的存储和遍历一,实验目的掌握图的邻接矩阵和邻接表存储以及图的邻接矩阵存储的递归遍历。

二,实验内容6.1实现图的邻接矩阵和邻接表存储编写一个程序,实现图的相关运算,并在此基础上设计一个主程序,完成如下功能:(1)建立如教材图7.9所示的有向图G的邻接矩阵,并输出。

(2)由有向图G的邻接矩阵产生邻接表,并输出。

(3)再由(2)的邻接表产生对应的邻接矩阵,并输出。

6.2 实现图的遍历算法(4)在图G的邻接矩阵存储表示基础上,输出从顶点V1开始的深度优先遍历序列(递归算法)。

(5)利用非递归算法重解任务(4)。

(6)在图G的邻接表存储表示基础上,输出从顶点V1开始的广度优先遍历序列。

三,源代码及结果截图#include<stdio.h>#include<stdlib.h>#include<string.h>#include<iostream.h>#include<malloc.h>#define MAX_VERTEX_NUM 20typedef char VRType;typedef int InfoType; // 存放网的权值typedef char VertexType; // 字符串类型typedef enum{DG,DN,AG,AN}GraphKind; // {有向图,有向网,无向图,无向网}/*建立有向图的邻接矩阵*/typedef struct ArcCell{VRType adj;//VRType是顶点关系类型,对无权图用1或0表示是否相邻;对带权图则为权值类型InfoType *info; //该弧相关信息的指针(可无)}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vexs[MAX_VERTEX_NUM];//顶点向量AdjMatrix arcs;//邻接矩阵int vexnum,arcnum;;//图的当前顶点数和弧数GraphKind kind;//图的种类标志}MGraph;/* 顶点在顶点向量中的定位*/int LocateVex(MGraph &M,VRType v1){int i;for(i=0;i<M.vexnum;i++)if(v1==M.vexs[i])return i;return -1;}void CreateGraph(MGraph &M)//建立有向图的邻接矩阵{int i,j,k,w;VRType v1,v2;M.kind=DN;printf("构造有向网:\n");printf("\n输入图的顶点数和边数(以空格作为间隔):");scanf("%d%d",&M.vexnum,&M.arcnum);printf("输入%d个顶点的值(字符):",M.vexnum);getchar();for(i=0;i<M.vexnum;i++) //输入顶点向量{scanf("%c",&M.vexs[i]);}printf("建立邻接矩阵:\n");for(i=0;i<M.vexnum;i++)for(j=0;j<M.vexnum;j++){M.arcs[i][j].adj=0;M.arcs[i][j].info=NULL;}printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");for(k=0;k<M.arcnum;++k)// 构造表结点链表{cin>>w>>v1>>v2;i=LocateVex(M,v1);j=LocateVex(M,v2);M.arcs[i][j].adj=w;}}//按邻接矩阵方式输出有向图void PrintGraph(MGraph M){int i,j;printf("\n输出邻接矩阵:\n");for(i=0; i<M.vexnum; i++){printf("%10c",M.vexs[i]);for(j=0; j<M.vexnum; j++)printf("%2d",M.arcs[i][j].adj);printf("\n");}}// 图的邻接表存储表示typedef struct ArcNode{int adjvex; // 该弧所指向的顶点的位置struct ArcNode *nextarc; // 指向下一条弧的指针InfoType *info; // 网的权值指针)}ArcNode; // 表结点typedef struct VNode{VertexType data; // 顶点信息ArcNode *firstarc; // 第一个表结点的地址,指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];// 头结点typedef struct{AdjList vertices;int vexnum,arcnum; // 图的当前顶点数和弧数int kind; // 图的种类标志}ALGraph;void CreateMGtoDN(ALGraph &G,MGraph &M){//由有向图M的邻接矩阵产生邻接表int i,j;ArcNode *p;G.kind=M.kind;G.vexnum=M.vexnum;G.arcnum=M.arcnum;for(i=0;i<G.vexnum;++i){//构造表头向量G.vertices[i].data=M.vexs[i];G.vertices[i].firstarc=NULL;//初始化指针}for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;++j)if(M.arcs[i][j].adj){p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;p->info=M.arcs[i][j].info;G.vertices[i].firstarc=p;}}void CreateDNtoMG(MGraph &M,ALGraph &G){ //由邻接表产生对应的邻接矩阵int i,j;ArcNode *p;M.kind=GraphKind(G.kind);M.vexnum=G.vexnum;M.arcnum=G.arcnum;for(i=0;i<M.vexnum;++i)M.vexs[i]=G.vertices[i].data;for(i=0;i<M.vexnum;++i){p=G.vertices[i].firstarc;while(p){M.arcs[i][p->adjvex].adj=1;p=p->nextarc;}//whilefor(j=0;j<M.vexnum;++j)if(M.arcs[i][j].adj!=1)M.arcs[i][j].adj=0;}//for}//输出邻接表void PrintDN(ALGraph G){int i;ArcNode *p;printf("\n输出邻接表:\n");printf("顶点:\n");for(i=0;i<G.vexnum;++i)printf("%2c",G.vertices[i].data);printf("\n弧:\n");for(i=0;i<G.vexnum;++i){p=G.vertices[i].firstarc;while(p){printf("%c→%c(%d)\t",G.vertices[i].data,G.vertices[p->adjvex].data,p->info);p=p->nextarc;}printf("\n");}//for}int visited[MAX_VERTEX_NUM]; // 访问标志数组(全局量)void(*VisitFunc)(char* v); // 函数变量(全局量)// 从第v个顶点出发递归地深度优先遍历图G。

数据结构课程设计-图的邻接矩阵

数据结构课程设计-图的邻接矩阵

数据结构课程设计报告设计题目:图的邻接矩阵存储结构院系计算机学院年级x 级学生xxxx学号xxxxxxxxxx指导教师xxxxxxxxx起止时间10-6/10-102013年10月10日目录1 需求分析 (3)2 概要设计 (4)2.1 ADT描述 (4)2.2程序模块结构 (5)2.3各功能模块 (6)3详细设计 (7)3.1类的定义 (7)3.2 初始化 (8)3.3 图的构建操作 (8)3.4 输出操作 (9)3.5 get操作 (9)3.6 插入操作 (10)3.7 删除操作 (10)3.8 求顶点的度操作 (11)3.10 判断连通操作 (12)3.11 主函数 (13)4 调试分析 (16)4.1调试问题 (16)4.2 算法时间复杂度 (16)5用户手册 (16)5.1 主界面 (16)5.2 创建图 (17)5.3插入节点 (17)5.4 深度优先遍历 (17)5.5 求各顶点的度 (18)5.6 输出图 (18)5.7 判断是否连通 (19)5.8 求边的权值 (19)5.9 插入边 (19)5.10 删除边 (20)结论 (20)参考文献 (20)摘要随着计算机的普及,涉及计算机相关的科目也越来越普遍,其中数据结构是计算机专业重要的专业基础课程与核心课程之一,为适应我国计算机科学技术的发展和应用,学好数据结构非常必要,然而要掌握数据结构的知识非常难,所以对“数据结构”的课程设计比不可少。

本说明书是对“无向图的邻接矩阵存储结构”课程设计的说明。

首先是对需求分析的简要阐述,说明系统要完成的任务和相应的分析,并给出测试数据。

其次是概要设计,说明所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次关系,以及ADT描述。

然后是详细设计,描述实现概要设计中定义的基本功操作和所有数据类型,以及函数的功能及代码实现。

再次是对系统的调试分析说明,以及遇到的问题和解决问题的方法。

然后是用户使用说明书的阐述,然后是测试的数据和结果的分析,最后是对本次课程设计的结论。

图论算法介绍

图论算法介绍

if (a[i,k]=1)and (a[k,j]=1) then a[i,j]=1 (a[i,j]=1表示i可达j,a[i,j]=0表示i不可达j)。
var
link,longlink:array[1..20,1..20] of boolean;{ 无向图和无向图的传递闭包。其

l o n g l i n k[i,
例如:公路交通图,边以距离w为权。

2
2
1
3
1
3
有向完全图 例
245
无向完全图 5
1
例 1
3
6
图与子图
57
32
46
G2
顶点5的度:3 顶点2的度:4
3
6
例 245
1
3
6
G1
顶点2入度:1 出度:3 顶点4入度:1 出度:0

路径:1,2,3,5,6,3 路径长度:5
245
简单路径:1,2,3,5
❖ 图 G = (V, E)
V = 顶点集 E = 边集 = V V的子集
结点集V={a, b, c, d} 边集E={e1, e2, e3, e4, e5} 其中e1=(a, b), e2=(a, c),
e3=(a, d), e4=(b, c), e5=(c, d)。
(一)、计算无向图的传递闭包
v1→v2→v4→v8→v5 →v3→v6→v7
算法结构:
调用一次dfs(i), 可按深度优先搜索 的顺序访问处理结 点i所在的连通分 支(或强连通分 支),dfs(i)的时 间复杂度为W(n2)。 整个图按深度优先 搜索顺序遍历的过 程如下:
显然,为了避免重复访问同一个顶点,必须 记住每个顶点是否被访问过。为此,可设置 一个布尔向量visited[1..n],它的初值为 false,一旦访问了顶点vi,便将visited[i] 置为ture。 图的深度优先搜索是一个递归过程,可以使 用栈来存储那些暂时不访问的邻接点.类似于 树的前序遍历,它的特点是尽可能先对纵深 方向进行搜索,故称之深度优先搜索。

邻接矩阵和邻接表 深度遍历和广度遍历原理

邻接矩阵和邻接表 深度遍历和广度遍历原理

邻接矩阵和邻接表是图论中用于表示图结构的两种常见方式,而深度遍历和广度遍历则是图论中常用的两种图遍历算法。

本文将从简介、原理和应用三个方面探讨这四个主题。

一、邻接矩阵和邻接表1.邻接矩阵邻接矩阵是一种使用二维数组来表示图中顶点之间关系的方法。

如果图中有n个顶点,那么对应的邻接矩阵就是一个n*n的矩阵,其中元素a[i][j]表示顶点i和顶点j之间是否有边,通常用0和1表示。

邻接矩阵适用于稠密图,其存储结构简单,可以直观地展示图的结构,但对于稀疏图来说可能会造成存储空间的浪费。

2.邻接表邻接表是一种使用链表来表示图中顶点之间关系的方法。

对于图中的每一个顶点,都维护一个相邻顶点的列表,图中所有顶点的列表再组合成一个链表,用于表示整个图的结构。

邻接表适用于稀疏图,其存储结构灵活,可以有效地节省存储空间,但查找任意两个顶点之间的关系可能会比较耗时。

二、深度遍历和广度遍历原理1.深度遍历深度遍历是一种用于遍历或搜索图中节点的算法,其原理是从图的某一顶点出发,沿着一条路径不断向下遍历直到末端,然后回溯到上一个节点继续遍历。

深度遍历使用栈来实现,可以通过递归或迭代来进行。

2.广度遍历广度遍历是一种用于遍历或搜索图中节点的算法,其原理是从图的某一顶点出发,依次访问其所有相邻节点,然后再依次访问这些相邻节点的相邻节点,以此类推。

广度遍历使用队列来实现。

三、深度遍历和广度遍历的应用1.深度遍历的应用深度遍历常用于求解图的连通分量、拓扑排序、解决迷宫问题等。

在连通分量中,深度遍历可以帮助我们找到图中的所有连通分量,并对其进行标记,用于进一步的算法运算。

在拓扑排序中,深度遍历可以帮助我们找到一个合理的顺序,用以处理依赖关系问题。

在解决迷宫问题时,深度遍历可以帮助我们找到一条从起点到终点的路径。

2.广度遍历的应用广度遍历常用于求解最短路径、解决迷宫问题等。

在求解最短路径中,广度遍历可以帮助我们找到起点到终点的最短路径,从而解决了许多实际问题。

图的遍历算法程序

图的遍历算法程序
}
else{
visited[k]=true;
printf("%c ",G.vexs[k]); //访问第k个顶点
for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))
if(!visited[i]) DFS(G,i); //对k的尚未访问的邻接顶点i递归调用DFS
#define MAX_VEX 20 //最大顶点个数
#define QUEUE_SIZE (MAX_VEX+1) //队列长度
using namespace std;
bool *visited; //访问标志数组
//图的邻接矩阵存储结构
typedef struct{
char *vexs; //顶点向量
if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum){ //i,j合理
for(int k=j+1;k<G.vexnum;k++)
if(G.arcs[i][k]!=INFINITY) return k;
}
return -1;
}
}
//主函数
void main(){
int i;
Graph G;
CreateUDN(G);
visited=(bool *)malloc(G.vexnum*sizeof(bool));
printf("\n广度优先遍历: ");
for(i=0;i<G.vexnum;i++)

图的定义和基本术语图的存储结构图的遍历生成树最短路径

图的定义和基本术语图的存储结构图的遍历生成树最短路径
操作结果: 在图G中增添新顶点v。
DeleteVex(&G, v) //删除顶点 初始条件: 图G存在, v和G中顶点有相同特性 。 操作结果:删除G中顶点v及其相关的弧。
InsertArc(&G, v, w) //插入弧 初始条件:图G存在,v 和w是G中两个顶点。 操作结果:在G中增添弧<v,w>,若G是无向的, 则还增添对称弧<w,v>。
DestroyGraph (&G ) // 销毁 初始条件:图G存在。 操作结果:销毁图G 。
LocateVex(G, u) // 定位 初始条件:图G存在,u 和G中顶点有相同特性 。 操作结果: 若G中存在顶点u ,则返回该顶点在 图中位置 ;否则返回其它信息。
GetVex(G, v)// 求值 初始条件:图G存在,v 是G中某个顶点。 操作结果:返回v的值。
//{有向图,有向网,无向图,无向网}
typedef struct ArcCell {// 弧的定义 VRType adj;//VRType是顶点关系类型。对无权图,
//用1或0表示相邻否;对带权图,则为权值类型。 InfoType *info; // 该弧相关信息的指针 } ArcCell ,
AdjMatrix[MAX_VERTEX_NUM] [MAX_VERTEX_NUM];
V2
V3
0110 0000 0001 10 0 0
//- -图的数组(邻接矩阵)存储表示--
#define INFINITY INT_MAX //最大值∞ #define MAX_VERTEX_NUM 20//最大顶点个数 typedef enum{DG,DN,UDG, UDN }graphkind;
表示,称为无向边;

图的遍历(深度优先遍历和广度优先遍历)

图的遍历(深度优先遍历和广度优先遍历)

遍历规则 从图中某结点v0出发,深度优先遍历(DFS: Depth First Search)图的规则为: 访问v0; 对v0的各个出点v01,v02,…,v0m,每次从它们中按一定方式(也可任选)选取一个未被访问过的结点,从该结点出发按深度优先遍历方式遍历。 然,因为我们没有规定对出点的遍历次序,所以,图的深度优先遍历结果一般不唯一。
20.2 深度优先遍历
例如,对图 20‑1给出的有向图与无向图,一些遍历结果(结点访问次序)为: 左图:从1出发:1,2,4,5;或1,5,2,4 从2出发:2,1,5,4;或2,4,1,5 右图:从a出发:a,b,c,d;或a,b,d,c; … …
A 如果不想让visited或top做为函数参数,也可以在函数中将其定义为static型量。但是,这样的程序是不可再入的,即函数再次被调用时,static型的量也不重新初始化,造成错误!
上面函数中的参数visited和top实质上是中间变量,只是为了避免在递归调用时重新初始化而放在参数表中,造成使用的不方便,为此,做个包装程序: long DFS1(int g[][CNST_NumNodes], long n, long v0, long *resu ) { char *visited; long top=0; visited = new char[n]; for (long i=0; i<n; i++) visited[i]=0; long num=DFS1( g, n, v0, visited, resu, top ); delete visited; return num; }
深度优先遍历非递归算法的一般性描述。
long DFS_NR(图g,结点v0)
单击此处可添加副标题
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五 图的邻接矩阵存储及遍历一、实验学时 2学时二、背景知识1.图的邻接矩阵存储结构设图G =(V ,E )有 n>=1个顶点,其编号分别为1,2,…,n 。

描述图G 的邻接矩阵为二维数组A[1…n ,1…n],A 的元素定义为:A []j i ,=⎩⎨⎧,,01否则)属于)或(若(E ,,i j j i v v v v显然无向图的邻接矩阵一定是对称的。

对于网,其邻接矩阵A 的元素定义为:A []j i ,=⎪⎩⎪⎨⎧∞=无邻接边到顶点若顶点若为该边上的权有邻接边,到顶点若顶点j i j i w j i w j i j i 0,,2.图的遍历深度优先遍历(DFS )法:算法步骤:1)初始化:(1)置所有顶点“未访问”标志;(2)打印起始顶点;(3)置起始顶点“已访问”标志;(4)起始顶点进栈。

2)当栈非空时重复做:(1)取栈顶点;(2)如栈顶顶点存在被访问过的邻接顶点,则选择一个顶点做:① 打印该顶点;② 置顶点为“已访问”标志;③ 该顶点进栈;否则,当前栈顶顶点退栈。

3)结束。

广度优先遍历(BFS )法:算法步骤:1) 初始化:(1)置所有顶点“未访问”标志;(2)打印起始顶点;(3)置起始顶点“已访问”标志;(4)起始顶点入队。

2)当队列非空时重复做:(1)取队首顶点;(2)对与队首顶点邻接的所有未被访问的顶点依次做:① 打印该顶点;② 置顶点为“已访问”标志;③ 该顶点入队;否则,当前队首顶点出队。

3) 结束。

三、目的要求1.掌握图的基本存储方法;2.掌握有关图的操作算法并用高级语言实现;3.熟练掌握图的两种搜索路径的遍历方法。

四、实验内容编写程序实现下图的邻接矩阵表示及其基础上的深度和广度优先遍历。

五、程序实例图的邻接矩阵表示法的C语言描述:#include<stdio.h>#include<conio.h>#include<stdlib.h>#define INFINITY 32767#define MAX_VERTEX_MUN 20int visited[20];typedef struct ArcCell{int adj;char *info;}ArcCell,AdjMatrix[20][20];typedef struct{char vexs[20];AdjMatrix arcs;int vexnum,arcnum;}MGragh;typedef struct QNode{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;int InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.front)exit(0);Q.front->next=NULL;return 1;}int EnQueue(LinkQueue &Q,int e){QueuePtr p;p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(0);p->next=NULL;p->data=e;Q.rear->next=p;Q.rear=p;return 1;}int DeQueue(LinkQueue &Q,int e){QueuePtr p;if(Q.front==Q.rear)exit(0);p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return 1;}int EmptyQueue(LinkQueue Q){if(Q.front==Q.rear)return 1;return 0;}int LocateVex(MGragh G,char v){ int t;for(t=0;t<G.vexnum;t++)if(v==G.vexs[t])return t;return -1;}int FirstAdjVex(MGragh G,char v){ int i,j;i=LocateVex(G,v);if(i==-1)return 0;for(j=0;j<G.vexnum;j++)if(G.arcs[i][j].adj==1)return j;return -1;}int NextAdjVex(MGragh G,char v,char w){int j,i1,i2;i1=LocateVex(G,v);i2=LocateVex(G,w);if(i1==-1||i2==-1||i1==i2)return 0;for(j=i2+1;j<G.vexnum;j++)if(G.arcs[i1][i2].adj==1)return j;return -1;}int Visit(char v){printf("%c",v);return 1;}//构造无向图int CreateUDG(MGragh &G){int v,e,i,j,t;char v1,v2;printf("input the number of the vertices:");scanf("%d",&v);if(v<0)return 0;G.vexnum=v;printf("input the number of the arcs:");scanf("%d",&e);if(e<0)return 0;G.arcnum=e;for(t=0;t<G.vexnum;t++){printf("input the vertice %d 's information",t+1);fflush(stdin);scanf("%c",&G.vexs[t]);}for(i=0;i<G.vexnum;i++)for(j=0;j<G.vexnum;j++){G.arcs[i][j].adj=INFINITY;G.arcs[i][j].info=NULL;}for(t=0;t<G.arcnum;t++){fflush(stdin);printf("input v1 and v2 is information :v1-v2");scanf("%c%*c%c",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);if(i==-1||j==-1||i==j)return 0;G.arcs[i][j].adj=G.arcs[j][i].adj=1;}return 1;}int BFSTraverse(MGragh G,int(*Visit)(char v)){LinkQueue Q;int v,w,u;for(v=0;v<G.vexnum;v++)visited[v]=0;InitQueue(Q);for(v=0;v<G.vexnum;v++){if(!visited[v]){visited[v]=1;Visit(G.vexs[v]);EnQueue(Q,v);while(!EmptyQueue(Q)){DeQueue(Q,v);w=FirstAdjVex(G,G.vexs[v]);for(;w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])) if(!visited[w]){visited[w]=1;Visit(G.vexs[w]);EnQueue(Q,w);}}}}return 1;}void DFS(MGragh G,int v){int w;visited[v]=1;Visit(G.vexs[v]);w=FirstAdjVex(G,G.vexs[v]);for(;w>=0;w=NextAdjVex(G,G.vexs[v],G.vexs[w])) if(!visited[w])DFS(G,w);}void DFSTraverse(MGragh G){int v;for(v=0;v<G.vexnum;v++)visited[v]=0;for(v=0;v<G.vexnum;v++)if(!visited[v])DFS(G,v);}void main(){MGragh G;printf("create the UND G:\n");if(CreateUDG(G)){printf("output the UDG G in DFS order:");DFSTraverse(G);printf("\n");printf("output the UDG G in BFS order:");BFSTraverse(G,Visit);printf("\n");}}。

相关文档
最新文档