数据结构图的建立和遍历
数据结构中的图的遍历算法
数据结构中的图的遍历算法图是一种非常重要且广泛应用的数据结构,它由顶点和边组成,可以用来表示各种实际问题,如社交网络、路线规划等。
图的遍历算法是对图中的所有顶点进行系统访问的方法,它可以用来查找、遍历和搜索图中的元素。
本文将介绍图的遍历算法的基本概念和常用的实现方法。
一、图的遍历算法概述图的遍历算法是指按照某种规则遍历图中的所有顶点,以便于查找、遍历和搜索图中的元素。
常用的图的遍历算法有深度优先搜索(DFS)和广度优先搜索(BFS)两种。
深度优先搜索(DFS)是一种先访问顶点的所有邻接顶点,再递归访问邻接顶点的邻接顶点的算法。
它以深度为优先级,一直向前走到不能继续为止,然后返回到前一个结点,继续向前走,直到遍历完整个图。
广度优先搜索(BFS)是一种先访问顶点的所有邻接顶点,再访问邻接顶点的邻接顶点,以此类推的算法。
它以广度为优先级,先访问离起始顶点最近的顶点,然后依次访问离起始顶点更远的顶点,直到遍历完整个图。
二、深度优先搜索(DFS)深度优先搜索是一种递归的搜索算法,它的基本思想是从图的某个顶点出发,沿着一条路径一直深入直到不能继续为止,然后返回到前一个结点,继续向前走。
具体实现时,可以使用递归或栈来保存需要访问的顶点。
以下是深度优先搜索的基本步骤:1. 选择一个起始顶点作为当前顶点,将其标记为已访问。
2. 访问当前顶点,并将其加入遍历结果。
3. 从当前顶点的未访问邻接顶点中选择一个作为下一个当前顶点,重复步骤2。
4. 如果当前顶点的所有邻接顶点都已访问,则返回到前一个顶点,重复步骤3。
5. 重复步骤4,直到遍历完整个图。
三、广度优先搜索(BFS)广度优先搜索是一种迭代的搜索算法,它的基本思想是从图的某个顶点出发,依次访问其所有未访问过的邻接顶点,然后再依次访问这些邻接顶点的未访问过的邻接顶点,直到遍历完整个图。
具体实现时,可以使用队列来保存需要访问的顶点。
以下是广度优先搜索的基本步骤:1. 选择一个起始顶点作为当前顶点,将其标记为已访问,并将其加入遍历结果。
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中,图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构,常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则,挨次访问图中的所有顶点,以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法1. 深度优先搜索(DFS)深度优先搜索是一种常用的图遍历算法,其基本思想是从一个顶点出发,沿着一条路径向来向下访问,直到无法继续为止,然后回溯到前一个顶点,再选择此外一条路径继续访问。
具体步骤如下:(1)选择一个起始顶点v,将其标记为已访问。
(2)从v出发,选择一个未被访问的邻接顶点w,将w标记为已访问,并将w入栈。
(3)如果不存在未被访问的邻接顶点,则出栈一个顶点,继续访问其它未被访问的邻接顶点。
(4)重复步骤(2)和(3),直到栈为空。
2. 广度优先搜索(BFS)广度优先搜索是另一种常用的图遍历算法,其基本思想是从一个顶点出发,挨次访问其所有邻接顶点,然后再挨次访问邻接顶点的邻接顶点,以此类推,直到访问完所有顶点。
具体步骤如下:(1)选择一个起始顶点v,将其标记为已访问,并将v入队。
(2)从队首取出一个顶点w,访问w的所有未被访问的邻接顶点,并将这些顶点标记为已访问,并将它们入队。
(3)重复步骤(2),直到队列为空。
三、图的遍历应用图的遍历算法在实际应用中有广泛的应用,下面介绍两个典型的应用场景。
1. 连通分量连通分量是指图中的一个子图,其中的任意两个顶点都是连通的,即存在一条路径可以从一个顶点到达另一个顶点。
图的遍历算法可以用来求解连通分量的个数及其具体的顶点集合。
具体步骤如下:(1)对图中的每一个顶点进行遍历,如果该顶点未被访问,则从该顶点开始进行深度优先搜索或者广度优先搜索,将访问到的顶点标记为已访问。
(2)重复步骤(1),直到所有顶点都被访问。
2. 最短路径最短路径是指图中两个顶点之间的最短路径,可以用图的遍历算法来求解。
数据结构实验报告图的遍历
数据结构实验报告图的遍历一、实验目的本实验旨在通过实践的方式学习图的遍历算法,掌握图的深度优先搜索(DFS)和广度优先搜索(BFS)的实现方法,加深对数据结构中图的理解。
二、实验步骤1. 创建图的数据结构首先,我们需要创建一个图的数据结构,以方便后续的操作。
图可以使用邻接矩阵或邻接表来表示,这里我们选择使用邻接矩阵。
class Graph:def__init__(self, num_vertices):self.num_vertices = num_verticesself.adj_matrix = [[0] * num_vertices for _ in range(num_vertic es)]def add_edge(self, v1, v2):self.adj_matrix[v1][v2] =1self.adj_matrix[v2][v1] =1def get_adjacent_vertices(self, v):adjacent_vertices = []for i in range(self.num_vertices):if self.adj_matrix[v][i] ==1:adjacent_vertices.append(i)return adjacent_vertices2. 深度优先搜索(DFS)DFS是一种遍历图的算法,其基本思想是从图的某一顶点开始,沿着一条路径一直走到最后,然后返回尚未访问过的顶点继续遍历,直到所有顶点都被访问过为止。
def dfs(graph, start_vertex):visited = [False] * graph.num_verticesstack = [start_vertex]while stack:vertex = stack.pop()if not visited[vertex]:print(vertex)visited[vertex] =Truefor neighbor in graph.get_adjacent_vertices(vertex):if not visited[neighbor]:stack.append(neighbor)3. 广度优先搜索(BFS)BFS同样是一种遍历图的算法,其基本思想是从图的某一顶点开始,首先访问其所有邻接点,然后再依次访问邻接点的邻接点,直到所有顶点都被访问过为止。
数据结构-实验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。
图的遍历的实验报告
图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构,它由一组节点和连接这些节点的边组成。
图的遍历是指从图中的某个节点出发,按照一定的规则依次访问图中的所有节点。
图的遍历在许多实际问题中都有广泛的应用,例如社交网络分析、路线规划等。
本实验旨在通过实际操作,深入理解图的遍历算法的原理和应用。
二、实验目的1. 掌握图的遍历算法的基本原理;2. 实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法;3. 比较并分析DFS和BFS算法的时间复杂度和空间复杂度。
三、实验过程1. 实验环境本实验使用Python编程语言进行实验,使用了networkx库来构建和操作图。
2. 实验步骤(1)首先,我们使用networkx库创建一个包含10个节点的无向图,并添加边以建立节点之间的连接关系。
(2)接下来,我们实现深度优先搜索算法。
深度优先搜索从起始节点开始,依次访问与当前节点相邻的未访问过的节点,直到遍历完所有节点或无法继续访问为止。
(3)然后,我们实现广度优先搜索算法。
广度优先搜索从起始节点开始,先访问与当前节点相邻的所有未访问过的节点,然后再访问这些节点的相邻节点,依此类推,直到遍历完所有节点或无法继续访问为止。
(4)最后,我们比较并分析DFS和BFS算法的时间复杂度和空间复杂度。
四、实验结果经过实验,我们得到了如下结果:(1)DFS算法的时间复杂度为O(V+E),空间复杂度为O(V)。
(2)BFS算法的时间复杂度为O(V+E),空间复杂度为O(V)。
其中,V表示图中的节点数,E表示图中的边数。
五、实验分析通过对DFS和BFS算法的实验结果进行分析,我们可以得出以下结论:(1)DFS算法和BFS算法的时间复杂度都是线性的,与图中的节点数和边数呈正比关系。
(2)DFS算法和BFS算法的空间复杂度也都是线性的,与图中的节点数呈正比关系。
但是,DFS算法的空间复杂度比BFS算法小,因为DFS算法只需要保存当前路径上的节点,而BFS算法需要保存所有已访问过的节点。
数据结构第七章:图
例
a c G1
b d
vexdata firstarc adjvex next 1 4 ^ a 2 3 4 b c d 1 1 3 ^ ^ ^
19
7.3 图的遍历
深度优先遍历(DFS) 深度优先遍历
方法:从图的某一顶点 出发,访问此顶点; 方法:从图的某一顶点V0出发,访问此顶点;然后依 次从V 的未被访问的邻接点出发,深度优先遍历图, 次从 0的未被访问的邻接点出发,深度优先遍历图, 直至图中所有和V 相通的顶点都被访问到; 直至图中所有和 0相通的顶点都被访问到;若此时图 中尚有顶点未被访问, 中尚有顶点未被访问,则另选图中一个未被访问的顶 点作起点,重复上述过程, 点作起点,重复上述过程,直至图中所有顶点都被访 问为止。 问为止。
ω ij , 若(v i , v j )或 < v i , v j >∈ E(G) A[i, j ] = 0,其它
11
例
1 3
5
2
8 4 7 5 1 6 3 4 2
0 5 7 0 3
5 0 0 4 8
7 0 0 2 1
0 4 2 0 6
3 8 1 6 0
12
关联矩阵——表示顶点与边的关联关系的矩阵 表示顶点与边的关联关系的矩阵 关联矩阵
1
7.1 图的定义和术语
是由两个集合V(G)和E(G)组成的 组成的, 图(Graph)——图G是由两个集合 图 是由两个集合 和 组成的 记为G=(V,E) 记为
其中: 其中:V(G)是顶点的非空有限集 是顶点的非空有限集 E(G)是边的有限集合,边是顶点的无序对或有序对 是边的有限集合, 是边的有限集合
有向图——有向图 是由两个集合 有向图G是由两个集合 有向图 有向图 是由两个集合V(G)和E(G)组成的 和 组成的
数据结构图
所以:对于点多边少的稀疏图来说,采用邻接表 结构使得算法在时间效 率上大大提高。
16
3/12
广度优先搜索(Breadth First Search,简称BFS ) BFS类似于树的层序遍历; 用一个数组用于标志已访问与否,还需要一个工作队列。
【例】一个无向图的BFS
8
6
CD
4
7
HG
BA
邻接多重表(Adjacency Multilist)
9
边表
• 在某些应用中,有时主要考察图中边的权值以及所依附的 两个顶点,即图的结构主要由边来表示,称为边表存储结 构。
• 边表结构采用顺序存储,用2个一维数组构成,一个存储 顶点信息,一个存储边的信息。边数组的每个元素由三部 分组成:
– 边的起点下标 – 边的终点下标 – 边的权值
1
A [i][
j]
0
如果 (vi , v j ) 或 vi , v j G的边 其它
无权图的邻接矩阵表示示例
V1
V2
V0
3
V3
4 12/15
带权图的邻接矩阵的定义
A [i][ j] wij
如果 (vi , vj ) 或 vi , v j G的边 其它
带图权的图邻的接邻矩接阵矩表阵示表示示例示[例例6.9]
1
第一部分 图的定义和术语
2
图的定义
“图” G可以表示为两个集合:G =(V, E)。每条 边是一个顶点对(v, w) E ,并且 v, w V。
通常:用 |V| 表示顶点的数量(|V| ≥ 1), 用 |E| 表示边的数量(|E| ≥ 0)。
(1) 无向图(完全有向图边数与顶点数之间的 关系) (2) 有向图(完全有向图弧数与顶点数之间的 关系) (3) 简单图:没有重边和自回路的图 (4) 邻接 (5) 路径,路径长度 (6) 无环(有向)图:没有任何回路的(有向)图 (7) 度,入度,出度 (8) 无向图的顶点连通、连通图、连通分量 (9) 有向图的顶点强连通,强连通图、连通分量
数据结构(C语言版)_第7章 图及其应用
实现代码详见教材P208
7.4 图的遍历
图的遍历是对具有图状结构的数据线性化的过程。从图中任 一顶点出发,访问输出图中各个顶点,并且使每个顶点仅被访 问一次,这样得到顶点的一个线性序列,这一过程叫做图的遍 历。
图的遍历是个很重要的算法,图的连通性和拓扑排序等算法 都是以图的遍历算法为基础的。
V1
V1
V2
V3
V2
V3
V4
V4
V5
图9.1(a)
图7-2 图的逻辑结构示意图
7.2.2 图的相关术语
1.有向图与无向图 2.完全图 (1)有向完全图 (2)无向完全图 3.顶点的度 4.路径、路径长度、回路、简单路径 5.子图 6.连通、连通图、连通分量 7.边的权和网 8.生成树
2. while(U≠V) { (u,v)=min(wuv;u∈U,v∈V-U); U=U+{v}; T=T+{(u,v)}; }
3.结束
7.5.1 普里姆(prim)算法
【例7-10】采用Prim方法从顶点v1出发构造图7-11中网所对 应的最小生成树。
构造过程如图7-12所示。
16
V1
V1
V2
7.4.2 广度优先遍历
【例7-9】对于图7-10所示的有向图G4,写出从顶点A出发 进行广度优先遍历的过程。
访问过程如下:首先访问起始顶点A,再访问与A相邻的未被 访问过的顶点E、F,再依次访问与E、F相邻未被访问过的顶 点D、C,最后访问与D相邻的未被访问过的顶点B。由此得到 的搜索序列AEFDCB。此时所有顶点均已访问过, 遍历过程结束。
【例7-1】有向图G1的逻辑结构为:G1=(V1,E1) V1={v1,v2,v3,v4},E1={<v1,v2>,<v2,v3>,<v2,v4>,<v3,v4>,<v4,v1>,<v4,v3>}
数据结构-第7章图答案
7.3 图的遍历 从图中某个顶点出发游历图,访遍图中其余顶点, 并且使图中的每个顶点仅被访问一次的过程。 一、深度优先搜索 从图中某个顶点V0 出发,访问此顶点,然后依次 从V0的各个未被访问的邻接点出发深度优先搜索遍 历图,直至图中所有和V0有路径相通的顶点都被访 问到,若此时图中尚有顶点未被访问,则另选图中 一个未曾被访问的顶点作起始点,重复上述过程, 直至图中所有顶点都被访问到为止。
void BFSTraverse(Graph G, Status (*Visit)(int v)) { // 按广度优先非递归遍历图G。使用辅助队列Q和访问标志数组 visited。 for (v=0; v<G.vexnum; ++v) visited[v] = FALSE; InitQueue(Q); // 置空的辅助队列Q for ( v=0; v<G.vexnum; ++v ) if ( !visited[v]) { // v尚未访问 EnQueue(Q, v); // v入队列 while (!QueueEmpty(Q)) { DeQueue(Q, u); // 队头元素出队并置为u visited[u] = TRUE; Visit(u); // 访问u for ( w=FirstAdjVex(G, u); w!=0; w=NextAdjVex(G, u, w) ) if ( ! visited[w]) EnQueue(Q, w); // u的尚未访问的邻接顶点w入队列Q
4。邻接多重表
边结点
mark ivex
顶点结点
ilink
jvex
jlink
info
data
firstedge
#define MAX_VERTEX_NUM 20 typedef emnu {unvisited, visited} VisitIf; typedef struct Ebox { VisitIf mark; // 访问标记 int ivex, jvex; // 该边依附的两个顶点的位置 struct EBox *ilink, *jlink; // 分别指向依附这两个顶点的下一条 边 InfoType *info; // 该边信息指针 } EBox; typedef struct VexBox { VertexType data; EBox *firstedge; // 指向第一条依附该顶点的边 } VexBox; typedef struct { VexBox adjmulist[MAX_VERTEX_NUM]; int vexnum, edgenum; // 无向图的当前顶点数和边数 } AMLGraph;
数据结构图的遍历实验报告doc
数据结构图的遍历实验报告篇一:【数据结构】图的存储和遍历实验报告《数据结构B》实验报告系计算机与电子专业级班姓名学号XX年1 0 月9日1. 上机题目:图的存储和遍历2. 详细设计#include#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define error printf#define QueueSize 30typedef struct{char vexs[GRAPHMAX];int edges[GRAPHMAX][GRAPHMAX];int n,e;}MGraph;int visited[10];typedef struct{int front,rear,count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q) {Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q){return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x) { if(QueueFull(Q)) error("Queue overflow");文档来源为:从网络收集整理.word 版本可编辑.欢迎下载支持else{ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;}}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){ error("Queue underflow");return NULL;}else{ temp=Q->data[Q->front]; Q->count--;Q->front=(Q->front+1)%QueueSize;return temp;}}void CreateMGraph(MGraph *G){int i,j,k;char ch1,ch2;printf("\n\t\t 请输入定点数,边数并按回车 (格式如:3,4):");scanf("%d,%d", &(G->n),&(G->e));for(i=0;in;i++){ getchar();printf("\n\t\t 请输入第%d个定点数并按回车:",i+1);scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->edges[i][j]=0;for(k=0;ke;k++){ getchar();printf("\n\t\t 请输入第%d条边的顶点序号 (格式如:i,j ):",k+1);scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->edges[i][j]=1;}}void DFSM(MGraph *G,int i){int j;printf("\n\t\t 深 度 优 列: %c\n",G->vexs[i]);visited[i]=TRUE;for(j=0;jn;j++)if(G->edges[i][j]==1 &&////////////////DFSM(G,j);} void BFSM(MGraph *G,int k){ int i,j;CirQueue Q;InitQueue(&Q);printf("\n\t\t 广 度 优列: %c\n",G->vexs[k]);visited[k]=TRUE;EnQueue(&Q,k); while(!QueueEmpty(&Q)){ i=DeQueue(&Q);先遍历序 visited[j]!=1)先遍历序for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) { visited[j]=TRUE;EnQueue(&Q,j);}}}void DFSTraverseM(MGraph *G) {int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) DFSM(G,i);}void BFSTraverseM(MGraph *G) {int i;for(i=0;in;i++) visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) BFSM(G,i);}void main(){MGraph *G,a;char ch1;int i,j,ch2;G=&a;printf("\n\t\t 建立一个有向图的邻接矩阵表示\n"); CreateMGraph(G);printf("\n\t\t 已建立一个有向图的邻接矩阵存储\n"); for(i=0;in;i++){ printf("\n\t\t");for(j=0;jn;j++)printf("%5d",G->edges[i][j]);}getchar();ch1='y';while(ch1=='y'||ch1=='Y'){ printf("\n");printf("\n\t\t 图的存储与遍历");("\n\t\t** ******************************");printf("\n\t\t*1 ---- 更新邻接矩阵*"); printf("\n\t\t*2 ---- 深度优先遍历*"); printf("\n\t\t*3 ---- 广度优先遍历*"); printf("\n\t\t*0 ---- 退出*");printf("\n\t\t** ******************************");}} printf("\n\t\t 请选择菜单号 ( 0 ---------------- 3) "); scanf("%d",&ch2); getchar(); switch(ch2) { case1:CreateMGraph(G); printf("\n\t\t 图的邻接矩阵存储建立完成\n");break; case 2:DFSTraverseM(G);break; case3:BFSTraverseM(G);break; case 0:ch1='n';break;default:printf("\n\t\t 输出错误!清重新输入!"); }3. 调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?由于实习之初对邻接表的存储结构了解不是很清楚,所以在运行出了一个小错误,即在输出邻接表时,每个结点都少了一个邻接点。
图的遍历数据结构实验报告
图的遍历数据结构实验报告正文:1·引言本实验报告旨在介绍图的遍历数据结构实验的设计、实现和结果分析。
图是一种常见的数据结构,用于表示对象之间的关系。
图的遍历是指系统地访问图的每个节点或边的过程,以便获取所需的信息。
在本次实验中,我们将学习并实现图的遍历算法,并分析算法的效率和性能。
2·实验目标本实验的主要目标是实现以下几种图的遍历算法:●深度优先搜索(DFS)●广度优先搜索(BFS)●拓扑排序3·实验环境本实验使用以下环境进行开发和测试:●操作系统:Windows 10●编程语言:C++●开发工具:Visual Studio 20194·实验设计与实现4·1 图的表示我们采用邻接矩阵的方式来表示图。
邻接矩阵是一个二维数组,用于表示图中节点之间的关系。
具体实现时,我们定义了一个图类,其中包含了节点个数、边的个数和邻接矩阵等属性和方法。
4·2 深度优先搜索算法(DFS)深度优先搜索是一种经典的图遍历算法,它通过递归或栈的方式实现。
DFS的核心思想是从起始节点开始,尽可能深地访问节点,直到达到最深的节点或无法继续访问为止。
我们实现了一个递归版本的DFS算法,具体步骤如下:●从起始节点开始进行递归遍历,标记当前节点为已访问。
●访问当前节点的所有未访问过的邻接节点,对每个邻接节点递归调用DFS函数。
4·3 广度优先搜索算法(BFS)广度优先搜索是另一种常用的图遍历算法,它通过队列的方式实现。
BFS的核心思想是从起始节点开始,逐层地遍历节点,先访问离起始节点最近的节点。
我们实现了一个使用队列的BFS算法,具体步骤如下:●将起始节点放入队列,并标记为已访问。
●从队列中取出一个节点,访问该节点并将其所有未访问的邻接节点放入队列。
●重复上述步骤,直到队列为空。
4·4 拓扑排序算法拓扑排序是一种将有向无环图(DAG)的所有节点线性排序的算法。
数据结构中图的遍历算法研究
数据结构中图的遍历算法研究作者:陈思薇来源:《课程教育研究》2018年第40期【摘要】图算法是数据结构与算法中一个比较重要的内容,而图的遍历算法是图算法的基础,也就是说其他的图算法都是在遍历算法的基础之上加以改进。
本篇论文主要介绍了两种图的遍历算法,分别是图的深度优先遍历和图的宽度优先遍历。
在介绍图的遍历算法之前,先介绍了图的基础知识,其中包括图的定义、邻接点和关联边、顶点的度、(强)连通图和图的表示方法。
介绍图的遍历算法时,依次介绍了遍历算法的基本步骤、程序框图和伪代码。
最后对全文做总结,并对图的遍历算法在未来如何应用的问题进行了展望。
【关键词】深度优先遍历 ;宽度优先遍历【中图分类号】G63 【文献标识码】A 【文章编号】2095-3089(2018)40-0222-021.引言遍历算法是目前计算机领域中的一个重要的研究方向,一个问题的求解就是从最开始的状态,利用已经存在的规则和条件改变当前状态,直到把当前状态变为最终目的状态,把中间出现的状态全部连接起来,变成一条遍历路径的过程。
通过图的遍历,我们可以找到这条路径[1]。
图的遍历算法主要有两种,一种是按照深度优先的顺序展开遍历的算法,也就是深度优先遍历[2];另一种是按照宽度优先的顺序展开遍历的算法,也就是宽度优先遍历[3]。
宽度优先遍历是沿着图的深度遍历图的所有节点,每次遍历都会沿着当前节点的邻接点遍历,直到所有点全部遍历完成。
如果当前节点的所有邻接点都遍历过了,则回溯到上一个节点,重复这一过程一直到已访问从源节点可达的所有节点为止。
如果还存在没有被访问的节点,则选择其中一个节点作为源节点并重复以上过程,直到所有节点都被访问为止。
利用图的深度优先搜索可以获得很多额外的信息,也可以解决很多图论的问题。
宽度优先遍历又名广度优先遍历。
通过沿着图的宽度遍历图的节点,如果所有节点均被访问,算法随即终止。
宽度优先遍历的实现一般需要一个队列来辅助完成。
数据结构图的遍历实验报告doc
数据结构图的遍历实验报告篇一:【数据结构】图的存储和遍历实验报告《数据结构B》实验报告系计算机与电子专业级班姓名学号XX年1 0月 9日1. 上机题目:图的存储和遍历2. 详细设计#include#define GRAPHMAX 10#define FALSE 0#define TRUE 1#define error printf#define QueueSize 30typedef struct{char vexs[GRAPHMAX];int edges[GRAPHMAX][GRAPHMAX];int n,e;}MGraph;int visited[10];typedef struct{int front,rear,count;int data[QueueSize];}CirQueue;void InitQueue(CirQueue *Q) {Q->front=Q->rear=0;Q->count=0;}int QueueEmpty(CirQueue *Q) {return Q->count=QueueSize;}int QueueFull(CirQueue *Q){return Q->count==QueueSize;}void EnQueue(CirQueue *Q,int x) {if(QueueFull(Q))error("Queue overflow");else{ Q->count++;Q->data[Q->rear]=x;Q->rear=(Q->rear+1)%QueueSize;}}int DeQueue(CirQueue *Q){int temp;if(QueueEmpty(Q)){ error("Queue underflow");return NULL;}else{ temp=Q->data[Q->front]; Q->count--; Q->front=(Q->front+1)%QueueSize; return temp;}}void CreateMGraph(MGraph *G){int i,j,k;char ch1,ch2;printf("\n\t\t请输入定点数,边数并按回车(格式如:3,4):");scanf("%d,%d",&(G->n),&(G->e));for(i=0;in;i++){ getchar();printf("\n\t\t请输入第%d个定点数并按回车:",i+1);scanf("%c",&(G->vexs[i]));}for(i=0;in;i++)for(j=0;jn;j++)G->edges[i][j]=0;for(k=0;ke;k++){ getchar();printf("\n\t\t请输入第%d条边的顶点序号(格式如:i,j):",k+1);scanf("%c,%c",&ch1,&ch2);for(i=0;ch1!=G->vexs[i];i++);for(j=0;ch2!=G->vexs[j];j++);G->edges[i][j]=1;}}void DFSM(MGraph *G,int i){int j;printf("\n\t\t深度优先遍历序列: %c\n",G->vexs[i]);visited[i]=TRUE;for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) ////////////////DFSM(G,j);}void BFSM(MGraph *G,int k){ int i,j;CirQueue Q;InitQueue(&Q);printf("\n\t\t广度优先遍历序列:%c\n",G->vexs[k]);visited[k]=TRUE;EnQueue(&Q,k);while(!QueueEmpty(&Q)){ i=DeQueue(&Q);for(j=0;jn;j++)if(G->edges[i][j]==1 && visited[j]!=1) { visited[j]=TRUE;EnQueue(&Q,j);}}}void DFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) DFSM(G,i);}void BFSTraverseM(MGraph *G){int i;for(i=0;in;i++)visited[i]=FALSE;for(i=0;in;i++)if(!visited[i]) BFSM(G,i);}void main(){MGraph *G,a;char ch1;int i,j,ch2;G=&a;printf("\n\t\t建立一个有向图的邻接矩阵表示\n");CreateMGraph(G);printf("\n\t\t已建立一个有向图的邻接矩阵存储\n");for(i=0;in;i++){ printf("\n\t\t");for(j=0;jn;j++)printf("%5d",G->edges[i][j]);}getchar();ch1='y';while(ch1=='y'||ch1=='Y'){ printf("\n");printf("\n\t\t图的存储与遍历 ");printf("\n\t\t********************************");printf("\n\t\t*1-----更新邻接矩阵*");printf("\n\t\t*2-----深度优先遍历*");printf("\n\t\t*3-----广度优先遍历*");printf("\n\t\t*0-----退出*");printf("\n\t\t********************************");}} printf("\n\t\t请选择菜单号(0----3)"); scanf("%d",&ch2); getchar(); switch(ch2) { case 1:CreateMGraph(G); printf("\n\t\t图的邻接矩阵存储建立完成\n");break; case 2:DFSTraverseM(G);break; case 3:BFSTraverseM(G);break; case 0:ch1='n';break; default:printf("\n\t\t输出错误!清重新输入!"); }3. 调试分析(1)调试过程中主要遇到哪些问题?是如何解决的?由于实习之初对邻接表的存储结构了解不是很清楚,所以在运行出了一个小错误,即在输出邻接表时,每个结点都少了一个邻接点。
图的建立及输出(图的遍历)
数据结构课程设计题目图的建立及输出学生姓名学号院系专业指导教师二O一O年12 月16 日目录一、设计题目 (2)二、运行环境(软、硬件环境) (2)三、算法设计的思想 (2)3.1邻接矩阵表示法 (2)3.2图的遍历 (4)3.3邻接矩阵的输出 (5)四、算法的流程图 (6)五、算法设计分析 (7)5.1无向网邻接矩阵的建立算法 (7)5.2无向图邻接矩阵的建立算法 (7)5.3图的深度优先遍历 (7)5.4图的广度优先遍历 (8)六、源代码 (8)七、运行结果分析 (14)八、收获及体会 (15)一、设计题目:图的建立及输出*问题描述:建立图的存储结构(图的类型可以是有向图、无向图、有向网、无向网,学生可以任选两种类型),能够输入图的顶点和边的信息,并存储到相应存储结构中,而后输出图的邻接矩阵。
二、运行环境(软、硬件环境)*软件环境:Windows7、 Windows Vista、 Windows Xp等*硬件环境:处理器:Pentium4以上内存容量: 256M以上硬盘容量:40GB 以上三、算法设计的思想1、邻接矩阵表示法:设G=(V,E)是一个图,其中V={V1,V2,V3…,Vn}。
G的邻接矩阵是一个他有下述性质的n阶方阵:1,若(Vi,Vj)∈E 或<Vi,Vj>∈E;A[i,j]={0,反之图5-2中有向图G1和无向图G2的邻接矩阵分别为M1和M2:M1=┌0 1 0 1 ┐│ 1 0 1 0 ││ 1 0 0 1 │└0 0 0 0 ┘M2=┌0 1 1 1 ┐│ 1 0 1 0 ││ 1 1 0 1 │└ 1 0 1 0 ┘注意无向图的邻接是一个对称矩阵,例如M2。
用邻接矩阵表示法来表示一个具有n个顶点的图时,除了用邻接矩阵中的n*n个元素存储顶点间相邻关系外,往往还需要另设一个向量存储n个顶点的信息。
因此其类型定义如下:VertexType vertex[MAX_VERTEX_NUM]; // 顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧(边)数GraphKind kind; // 图的种类标志若图中每个顶点只含一个编号i(1≤i≤vnum),则只需一个二维数组表示图的邻接矩阵。
数据结构实验 图的邻接表和邻接矩阵操作
p->weight=weight; p->nextarc=G.vertices[vv].firstarc; G.vertices[vv].firstarc=p; strcmp(G.vertices[vv].data,v);
q=(ArcNode *)malloc(sizeof(ArcNode)); q->adjvex=vv; q->weight=weight; q->nextarc=G.vertices[ww].firstarc; G.vertices[ww].firstarc=q; strcmp(G.vertices[ww].data,w);
实验报告 6
课程 数据结构 实验名称 图的建立及遍历
第页
专业
班级_ __ 学号_ ___ 姓名
实验日期: 2010 年 11 月 23 日
评分
一 、实验目的
1.学会用邻接矩阵和邻接表实现图结构和对图的基本操作。 2.掌握对图操作的具体实现; 3. 掌握图的两种遍历算法(深度优先、广度优先); 4、掌握求图的最小生成树和顶点间最短路径的算法;
int adjvex;//该弧指向的顶点的位置 ArcType weight; struct ArcNode *nextarc;//指向下一条弧指针 //InfoType *info;该弧相关信息的指针 }ArcNode; typedef struct VNode { VertexType data;//顶点信息 ArcNode *firstarc;//指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; GraphKind kind; }ALGraph; ALGraph G; struct MiniSpanTree_Flag { VertexType adjvex; ArcType lowcost; }closedge[MAX_VEX_NUM]; typedef bool PathMatrix[MAX_VEX_NUM][MAX_VEX_NUM];
数据结构中的常见问题与解决方案
数据结构中的常见问题与解决方案数据结构是计算机科学中非常重要的基础知识,它是用来组织和存储数据的一种特殊方式。
在实际的编程过程中,我们经常会遇到各种关于数据结构的问题,如何选择合适的数据结构、如何高效地操作数据结构等等。
本文将介绍数据结构中的一些常见问题,并给出相应的解决方案。
一、数组越界访问数组是一种最基本的数据结构,它由一组连续的内存空间组成,可以存储相同类型的数据。
在使用数组时,经常会出现数组越界访问的问题,即访问数组中不存在的索引位置。
这种错误通常会导致程序崩溃或产生不可预测的结果。
解决方案:1. 在编程过程中,要时刻注意数组的索引范围,避免越界访问。
2. 使用边界检查来确保数组访问的合法性,可以在访问数组元素之前进行索引范围的检查。
3. 在编程语言中,一些工具和库提供了数组越界检查的功能,可以利用这些工具来避免越界访问的问题。
二、链表中的循环引用链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在使用链表时,可能会出现循环引用的问题,即链表中的某个节点指向了链表中的前面节点,导致链表形成了一个环。
解决方案:1. 使用快慢指针来检测链表中是否存在循环引用,快指针每次移动两步,慢指针每次移动一步,如果两个指针相遇,则说明链表中存在循环引用。
2. 在插入和删除节点时,要注意更新节点之间的指针关系,避免出现循环引用的情况。
3. 可以使用哈希表来存储已经访问过的节点,当遍历链表时,检查当前节点是否已经存在于哈希表中,如果存在则说明存在循环引用。
三、栈和队列的应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特性,在实际编程中有着广泛的应用。
在使用栈和队列时,可能会遇到一些问题,如如何实现栈和队列、如何高效地进行操作等。
解决方案:1. 对于栈的实现,可以使用数组或链表来存储数据,通过压栈和出栈操作来实现栈的功能。
在使用数组实现栈时,要注意栈的扩容和缩容操作,以提高效率。
数据结构图的存储结构及基本操作
数据结构图的存储结构及基本操作一、数据结构图的存储结构数据结构图是一种表示数据元素之间关系的图形结构,常用于描述实体之间的关系、网络拓扑结构等。
数据结构图的存储结构可以使用邻接矩阵、邻接表等方式进行表示。
1.邻接矩阵存储结构邻接矩阵是使用二维数组表示数据结构图的存储结构。
数组的行和列分别代表数据结构图中的顶点,矩阵中的元素表示对应顶点之间的关系。
例如,如果顶点i和顶点j之间存在边,则邻接矩阵中(i,j)位置的元素为1;否则为0。
邻接矩阵的优点是可以快速判断两个顶点之间是否存在边,但缺点是当图中顶点较多时,矩阵中大部分元素为0,造成空间浪费。
2.邻接表存储结构邻接表是使用链表表示数据结构图的存储结构。
每个顶点对应一个链表,链表中的节点表示与该顶点直接相连的其他顶点。
顶点的链表可以使用数组或链表等数据结构来表示。
邻接表的优点是可以有效地利用存储空间,只存储存在边的关系,不存储无关边的信息。
但缺点是判断两个顶点之间是否存在边需要遍历链表,时间复杂度较高。
二、数据结构图的基本操作1.创建数据结构图创建数据结构图的操作是初始化一个空的图结构,可以选择使用邻接矩阵或邻接表存储结构。
根据实际需求,可以根据顶点和边的信息逐个添加到图结构中。
2.添加顶点添加顶点是向数据结构图中增加一个新的顶点,可以根据实际需求给顶点赋予相应的值或标识。
添加顶点的操作需要更新邻接矩阵或邻接表的相应位置。
3.添加边添加边是在两个已存在的顶点之间建立连接关系。
根据实际需求,可以指定边的权重或其他属性。
添加边的操作需要更新邻接矩阵或邻接表的相应位置。
4.删除顶点删除顶点是将一个存在的顶点从图结构中移除,同时将与该顶点相关的边也一并删除。
删除顶点的操作需要更新邻接矩阵或邻接表的相应位置。
5.删除边删除边是在两个已存在的顶点之间断开连接关系。
删除边的操作需要更新邻接矩阵或邻接表的相应位置。
6.查找顶点查找顶点是根据给定的值或标识在图结构中查找相应的顶点。
图的遍历数据结构实验报告
图的遍历数据结构实验报告图的遍历数据结构实验报告1. 实验目的本实验旨在通过使用图的遍历算法,深入理解图的数据结构以及相关算法的运行原理。
2. 实验背景图是一种非线性的数据结构,由顶点和边组成。
图的遍历是指按照某种规则,从图中的一个顶点出发,访问图中的所有顶点且仅访问一次的过程。
3. 实验环境本次实验使用的操作系统为Windows 10,编程语言为Python3.8,使用的图数据结构库为NetworkX。
4. 实验步骤4.1 创建图首先,我们使用NetworkX库创建一个有向图。
通过调用add_nodes_from()方法添加顶点,并调用add_edge()方法添加边,构建图的结构。
4.2 深度优先搜索(DFS)接下来,我们使用深度优先搜索算法来遍历这个图。
深度优先搜索是一种递归的遍历法,从一个顶点开始,沿着深度方向访问图中的顶点,直到不能继续深入为止。
4.3 广度优先搜索(BFS)然后,我们使用广度优先搜索算法来遍历这个图。
广度优先搜索是一种先访问离起始顶点最近的顶点的遍历法,从一个顶点开始,依次访问与之相邻的顶点,直到访问完所有的顶点为止。
5. 实验结果我们根据深度优先搜索和广度优先搜索算法,分别得到了图的遍历结果。
通过实验可以观察到每种遍历方式所访问的顶点顺序以及所需的时间复杂度。
6. 结论通过本次实验,我们了解了图的遍历数据结构及相关算法的原理和实现方式。
深度优先搜索和广度优先搜索算法适用于不同的场景,可以根据具体情况选择合适的算法进行图的遍历。
附件:无附录:本文所涉及的法律名词及注释:- 图:由结点和边组成的非线性数据结构。
- 顶点:图中的每个元素都称为顶点,也称为结点。
- 边:顶点之间的连接关系称为边。
2017唐班数据结构-13_2图的遍历
v=Q.delete(); /* 出队 */ cout<<v; for ( p = Head[v]->adjacent ; p ; p = p->link ) .
图的连通性:非连通图中,从一个顶点出发,只能访 问它所在的连通分量上的所有顶点。用户指定下一个 出发点访问其它连通分量。
重复访问:访问完某个顶点后可能沿着某些边又回到 曾经访问过的顶点。避免重复,用标识数组visited[ ]。 初值为0,标识未访问。如果顶点 i 被访问,则置 visited[i]为1.
✓ 下推上: 显然 ✓ 上推下: 数学归纳法
应用1 求无向图的连通分支数
思想:每遍历一个连通分支,计数加1 遍历用深搜和广搜均可
应用2 判断图中是否有环
方法非常多;下面考虑用图的遍历求解
思想:深搜时,每个结点有两个状态,标记是 否被访问过(0未访问,1已访问过)。判环时, 多引入一个状态,标记结点正在访问中(-1正 在访问中)。如果一个结点正在访问中,又遍 历到该接点,那个存在环路。这种状况是由于 出现了反向边,即后代指向祖先的边。
如果使用邻接矩阵,则对于每一个被访问的顶 点,循环要检测矩阵中的 n 个元素,总的时间 代价为O(n2)。
定理5.1
DFS每次遍历一个连通分支 Vs = { v | v ∈ V 且 s ->E* v } Vs = { v | v ∈ V 且 visited[v] = 1 }
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程名称:数据结构开课实验室:计算中心204室2011年10 月日
年级、专业、班学号姓名成绩
实验项目名称图的建立和遍历指导教师
教师
评语
教师签名:
年月日
一、实验内容和目的
目的:撑握图的建立和遍历,熟悉图的建立和输出,还有两种遍历(深度和广度优先遍历)。
内容:编出图的程序,能够体图的性质、内容和算法。
二、上机实验环境
计算中心204;操作系统:Microsoft Visual C++;软件平台:Microsoft Visual C++ 三、上机操作方法、步骤
打开计算机进入WindowsXP→在桌面建立自己的工作目录→进入Microsoft Visual C++ 6.0→文件/新建/文件/C++ Source File/位置/命名→输入源程序→编译/组建→运行。
四、设计分析:
图是一种复杂的非线性结构。
图结构在人工智能、计算机科学等领域有着广泛的运用。
学好它就得了解结点之间的关系是线性关系,除开始结点和终端结点外,每个结点只有一个直接前趋和直接后继。
在图结构中,对结点的前趋和后继个数都不加限制的,即结点之间的关系是任意的。
#include <stdio.h>
#include<malloc.h>
#define maxnode 30
#define null 0
#define m 20
typedef struct st_arc
{
int adjvex;
int weight;
struct st_arc *nextarc;
}arcnode;
typedef struct
{
int vertex;
struct st_arc *firstarc;
}vernode;
typedef vernode adjlist[maxnode];
int queue[maxnode];
void dfs(adjlist g,int k,int visited[]) //从顶点K出发深度优先搜索{
arcnode *p;
int w;
visited[k]=1;
printf("%d ",g[k].vertex);
p=g[k].firstarc;
while(p!=null)
{
w=p->adjvex;
if(visited[w]==0)
dfs(g,w,visited);
p=p->nextarc;
}
}
void bfs(adjlist g,int k,int visited[]) //从顶点K出发广度优先搜索{
int front=0,rear=1,w;
arcnode *p;
visited[k]=1; //访问初始顶点
printf("%d ",k);
queue[rear]=k; //初始顶点入队列
while(front!=rear)
{
front=(front+1)%m;
w=queue[front]; //按访问次序依次出队列
p=g[w].firstarc;
while(p!=null)
{
if(visited[p->adjvex]==0)
{
visited[p->adjvex]=1;
printf("%d ",p->adjvex);
rear=(rear+1)%m;
queue[rear]=p->adjvex;;
}
p=p->nextarc;
}
}
}
void trave_bfs(adjlist g,int n) //数组visited标志图中的顶点是否已被访问{
int i,visited[maxnode];
for(i=1;i<=n;i++)
visited[i]=0;
for(i=1;i<=n;i++)
if(visited[i]==0)
bfs(g,i,visited);
}
void trave_dfs(adjlist g,int n) //数组visited标志图中的顶点是否已被访问{
int i,visited[maxnode];
for(i=1;i<=n;i++)
visited[i]=0;
for(i=1;i<=n;i++)
if(visited[i]==0)
dfs(g,i,visited);
}
void print(adjlist g,int n)
{
arcnode *q;
int i;
printf("输出的是所建立无向图的邻接表结构:\n");
for(i=1;i<=n;i++)
{
printf("\t%d\t",i);
printf("%d->",g[i].vertex);
q=g[i].firstarc;
while(q!=null)
{
printf("%d,",q->adjvex);
printf("%d->",q->weight);
q=q->nextarc;
}
printf("Null");
printf("\n");
}
}
void main()
{
arcnode *p,*q;
adjlist g;
int i,j,n,k,w,e;
printf("请输入建立的无向图所包含的顶点总个数和总边数(用逗号隔开):");
scanf("%d,%d",&n,&e);
for(k=1;k<=n;k++)
{
getchar();
printf("\t输入每个顶点的信息,必须输入整数值:",k);
scanf("%d",&g[k].vertex);
g[k].firstarc=null; //对顺序存储部分初始化
}
for(k=1;k<=e;k++)
{
printf("输入所有边的信息,(起始顶点,终止顶点和该边的权值 %d 如1,2,3):",k);
scanf("%d,%d,%d",&i,&j,&w);
q=(arcnode *)malloc(sizeof(arcnode));
q->adjvex=j;
q->weight=w;
q->nextarc=g[i].firstarc;
g[i].firstarc=q;
p=(arcnode *)malloc(sizeof(arcnode));
p->adjvex=i;
p->weight=w;
p->nextarc=g[j].firstarc;
g[j].firstarc=p;
}
print(g,n);
printf("\n");
printf("输出深度优先搜索遍历:");
trave_dfs(g,n);
printf("\n");
printf("输出广度优先搜索遍历:");
trave_bfs(g,n);
printf("\n");
}
五、源程序与运行结果:
五、上机实践收获和体会:
经过学习和上机实践,我基本了解和撑握图的基本概念和两种常用的存储结构,对图的遍历、最小生成树、最短路弃、拓扑排序等理解,撑握图的有关术语和存储表示。