图的建立与遍历实验报告

图的遍历实验报告一、引言图是一种非线性的数据结构，由一组节点（顶点）和节点之间的连线（边）组成。

图的遍历是指按照某种规则依次访问图中的每个节点，以便获取或处理节点中的信息。

图的遍历在计算机科学领域中有着广泛的应用，例如在社交网络中寻找关系紧密的人员，或者在地图中搜索最短路径等。

本实验旨在通过实际操作，掌握图的遍历算法。

在本实验中，我们将实现两种常见的图的遍历算法：深度优先搜索（DFS）和广度优先搜索（BFS），并比较它们的差异和适用场景。

二、实验目的1. 理解和掌握图的遍历算法的原理与实现；2. 比较深度优先搜索和广度优先搜索的差异；3. 掌握图的遍历算法在实际问题中的应用。

三、实验步骤实验材料1. 计算机；2. 编程环境（例如Python、Java等）；3. 支持图操作的相关库（如NetworkX）。

实验流程1. 初始化图数据结构，创建节点和边；2. 实现深度优先搜索算法；3. 实现广度优先搜索算法；4. 比较两种算法的时间复杂度和空间复杂度；5. 比较两种算法的遍历顺序和适用场景；6. 在一个具体问题中应用图的遍历算法。

四、实验结果1. 深度优先搜索（DFS）深度优先搜索是一种通过探索图的深度来遍历节点的算法。

具体实现时，我们可以使用递归或栈来实现深度优先搜索。

算法的基本思想是从起始节点开始，选择一个相邻节点进行探索，直到达到最深的节点为止，然后返回上一个节点，再继续探索其他未被访问的节点。

2. 广度优先搜索（BFS）广度优先搜索是一种逐层遍历节点的算法。

具体实现时，我们可以使用队列来实现广度优先搜索。

算法的基本思想是从起始节点开始，依次遍历当前节点的所有相邻节点，并将这些相邻节点加入队列中，然后再依次遍历队列中的节点，直到队列为空。

3. 时间复杂度和空间复杂度深度优先搜索和广度优先搜索的时间复杂度和空间复杂度如下表所示：算法时间复杂度空间复杂度深度优先搜索O(V+E) O(V)广度优先搜索O(V+E) O(V)其中，V表示节点的数量，E表示边的数量。

-实验三、图的遍历操作一、目的掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储构造；掌握DFS及BFS对图的遍历操作；了解图构造在人工智能、工程等领域的广泛应用。

二、要求采用邻接矩阵和邻接链表作为图的存储构造，完成有向图和无向图的DFS 和BFS操作。

三、DFS和BFS 的根本思想深度优先搜索法DFS的根本思想：从图G中*个顶点Vo出发，首先访问Vo，然后选择一个与Vo相邻且没被访问过的顶点Vi访问，再从Vi出发选择一个与Vi相邻且没被访问过的顶点Vj访问，……依次继续。

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

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

广度优先算法BFS的根本思想：从图G中*个顶点Vo出发，首先访问Vo，然后访问与Vo相邻的所有未被访问过的顶点V1，V2，……，Vt；再依次访问与V1，V2，……，Vt相邻的起且未被访问过的的所有顶点。

如此继续，直到访问完图中的所有顶点。

四、例如程序1．邻接矩阵作为存储构造的程序例如#include"stdio.h"#include"stdlib.h"#define Ma*Verte*Num 100 //定义最大顶点数typedef struct{char ve*s[Ma*Verte*Num]; //顶点表int edges[Ma*Verte*Num][Ma*Verte*Num]; //邻接矩阵，可看作边表int n,e; //图中的顶点数n和边数e}MGraph; //用邻接矩阵表示的图的类型//=========建立邻接矩阵=======void CreatMGraph(MGraph *G){int i,j,k;char a;printf("Input Verte*Num(n) and EdgesNum(e): ");scanf("%d,%d",&G->n,&G->e); //输入顶点数和边数scanf("%c",&a);printf("Input Verte* string:");for(i=0;i<G->n;i++){scanf("%c",&a);G->ve*s[i]=a; //读入顶点信息，建立顶点表}for(i=0;i<G->n;i++)for(j=0;j<G->n;j++)G->edges[i][j]=0; //初始化邻接矩阵printf("Input edges,Creat Adjacency Matri*\n");for(k=0;k<G->e;k++) { //读入e条边，建立邻接矩阵 scanf("%d%d",&i,&j); //输入边〔Vi，Vj〕的顶点序号G->edges[i][j]=1;G->edges[j][i]=1; //假设为无向图，矩阵为对称矩阵；假设建立有向图，去掉该条语句}}//=========定义标志向量，为全局变量=======typedef enum{FALSE,TRUE} Boolean;Boolean visited[Ma*Verte*Num];//========DFS：深度优先遍历的递归算法======void DFSM(MGraph *G,int i){ //以Vi为出发点对邻接矩阵表示的图G进展DFS搜索，邻接矩阵是0，1矩阵 int j;printf("%c",G->ve*s[i]); //访问顶点Vivisited[i]=TRUE; //置已访问标志for(j=0;j<G->n;j++) //依次搜索Vi的邻接点if(G->edges[i][j]==1 && ! visited[j])DFSM(G,j); //〔Vi，Vj〕∈E，且Vj未访问过，故Vj为新出发点}void DFS(MGraph *G){int i;for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)if(!visited[i]) //Vi未访问过DFSM(G,i); //以Vi为源点开场DFS搜索}//===========BFS：广度优先遍历=======void BFS(MGraph *G,int k){ //以Vk为源点对用邻接矩阵表示的图G进展广度优先搜索 int i,j,f=0,r=0;int cq[Ma*Verte*Num]; //定义队列for(i=0;i<G->n;i++)visited[i]=FALSE; //标志向量初始化for(i=0;i<G->n;i++)cq[i]=-1; //队列初始化printf("%c",G->ve*s[k]); //访问源点Vkvisited[k]=TRUE;cq[r]=k; //Vk已访问，将其入队。

图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构，它由一组节点和连接这些节点的边组成。

图的遍历是指从图中的某个节点出发，按照一定的规则依次访问图中的所有节点。

图的遍历在许多实际问题中都有广泛的应用，例如社交网络分析、路线规划等。

本实验旨在通过实际操作，深入理解图的遍历算法的原理和应用。

二、实验目的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算法需要保存所有已访问过的节点。

1.问题描述：不少涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序，演示在连通的无向图上访问全部结点的操作。

2.基本要求：以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。

3.测试数据：教科书图7.33。

暂时忽略里程，起点为北京。

4.实现提示：设图的结点不超过30个，每一个结点用一个编号表示(如果一个图有n个结点，则它们的编号分别为1,2,…,n)。

通过输入图的全部边输入一个图，每一个边为一个数对，可以对边的输入顺序作出某种限制，注意，生成树的边是有向边，端点顺序不能颠倒。

5.选作内容：(1) .借助于栈类型(自己定义和实现)，用非递归算法实现深度优先遍历。

(2) .以邻接表为存储结构，建立深度优先生成树和广度优先生成树，再按凹入表或者树形打印生成树。

1.为实现上述功能，需要有一个图的抽象数据类型。

该抽象数据类型的定义为：ADT Graph{V 是具有相同特性的数据元素的集合，称为顶点集。

R={VR}VR={<v，w> | v ，w v 且P(v，w)，<v，w>表示从v 到w 得弧，谓词P(v，w)定义了弧<v，w>的意义或者信息}} ADT Graph2.此抽象数据类型中的一些常量如下：#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};3.树的结构体类型如下所示：typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。

图--0,1;网--权值int *Info; //与弧相关的信息的指针,可省略}ArcCell, AdjMatrix[max_n][max_n];typedef struct{VertexType vexs[max_n]; //顶点AdjMatrix arcs; //邻接矩阵int vexnum, arcnum; //顶点数，边数}MGraph;//队列的类型定义typedef int QElemType;typedef struct QNode{QElemType data;struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;4.本程序包含三个模块1).主程序模块void main( ){创建树；深度优先搜索遍历；广度优先搜索遍历；}2).树模块——实现树的抽象数据类型3).遍历模块——实现树的深度优先遍历和广度优先遍历各模块之间的调用关系如下：主程序模块树模块遍历模块#include "stdafx.h"#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define max_n 20 //最大顶点数typedef char VertexType[20];typedef enum{DG, DN, AG, AN} GraphKind;enum BOOL{False,True};typedef struct{ //弧结点与矩阵的类型int adj; //VRType为弧的类型。

实验五图的遍历及其应用实现一、实验目的1．熟悉图常用的存储结构。

2．掌握在图的邻接矩阵和邻接表两种结构上实现图的两种遍历方法实现。

3．会用图的遍历解决简单的实际问题。

二、需求分析很多问题都是建立在图的遍历的基础上实现的，所以必须有一个程序能够实现将图进行广度和深度遍历，必须对图的所有节点进行访问。

以无向图为例，以无向图的邻接表和邻接矩阵为存储结构，分别实现对图进行广度和深度遍历。

以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应的生成树的边集。

三、实验内容[题目一] ：从键盘上输入图的顶点和边的信息,建立图的邻接表存储结构,然后以深度优先搜索和广度优先搜索遍历该图,并输出起对应的遍历序列. 试设计程序实现上述图的类型定义和基本操作,完成上述功能。

该程序包括图类型以及每一种操作的具体的函数定义和主函数。

提示：输入示例上图的顶点和边的信息输入数据为：5 7 DGA B C D EAB AE BC CD DA DB EC四、结构算法模块：typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;五、相关函数设计Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历BFSTraverse(ALGraph G)//有向图的广度遍历，从第v个顶点出发，v为顶点下标locatevex(ALGraph G,char v)//图的基本操作，寻找顶点位置的下标DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G六、程序流程图七、运行结果截图最初程序运行界面如下：输入图的先相关信息后运行结果(其中深度优先遍历的起点选择的是字符所在序列的序号，且0是起点)，一下是深度优先遍历时选择不同的起点所出现的最终运行结果：程序源代码：//图的邻接表表示：#include<iostream>#include<malloc.h>#include<queue>using namespace std;# define MAX_VEX_NUM 20//宏定义数组最大int visited[MAX_VEX_NUM];//设置标志数组queue<int>q;typedef struct ArcNode//定义邻接表结构{int adjvex;//该弧所指向的顶点的位置struct ArcNode *nextarc;//指向下一条弧的指针}ArcNode;typedef struct VNode//定义顶点结构类型{char data;//存放顶点信息ArcNode *firstarc;//指向第一条依附于该定点的指针}VNode,Adjlist[MAX_VEX_NUM];typedef struct ALGraph{Adjlist vertices;int vexnum;int arcnum;}ALGraph;ALGraph G;//申明一个无向图的邻接矩阵类型int locatevex(ALGraph G,char v)//图的基本操作，寻找顶点位置的下标{int i=0;while(i<G.vexnum && v!=G.vertices[i].data)i++;if(i<G.vexnum)return i;}void Create_DG(ALGraph &G)//创建一个有向图图的邻接链表表示{cout<<"请输入图的顶点数和弧数:"<<endl;cin>>G.vexnum;cin>>G.arcnum;char v1;char v2;int v1locate;int v2locate;ArcNode * p;cout<<"输入图的顶点信息"<<endl;for(int i=0;i<G.vexnum;i++)//构造表头向量{cin>>G.vertices[i].data;//输入顶点值G.vertices[i].firstarc=NULL;//初始化指针}cout<<"请输入从起点到终点的一条弧所对应的顶点"<<endl; for(int k=1;k<=G.arcnum;k++)//输入各弧并创建十字链表{cin>>v1>>v2;//输入一条弧的起点和终点v1locate=locatevex(G,v1);//确定v1在图G中位置v2locate=locatevex(G,v2);//确定v2在图G中位置p=new ArcNode;//假定有足够空间p->adjvex=v2locate;//有一条弧指向v2p->nextarc=G.vertices[v1locate].firstarc;//对弧节点赋值G.vertices[v1locate].firstarc=p;//完成在入弧和出弧链表的插入/*q=new ArcNode;q->adjvex=v1locate;q->nextarc=G.vertices[v2locate].firstarc;G.vertices[v2locate].firstarc=q;*/}}//Create_DGvoid DFS(ALGraph G,int v)//从第v个顶点出发递归地深度优先遍历图G {visited[v]=1;//访问第v个节点cout<<G.vertices[v].data<<" ";//输出节点值for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc){if(!visited[p->adjvex])DFS(G,p->adjvex);//对v的尚未访问的邻接顶点p递归调用dfs}}//DFSvoid DFSTraverse(ALGraph G,int vex)//对图G做深度优先遍历{for(int i = 0;i < G.vexnum;i++)visited[i]=0; //访问数组初始化DFS(G,vex); //先对图从指定定点访问for(int v = 0;v < G.vexnum;v ++) //对可能出现的子图遍历if(!visited[v]) //对尚未访问的顶点调用dfsDFS(G,v);}//DFSTraverseint BFSTraverse(ALGraph G)//无向图的广度遍历，从第v个顶点出发，v 为顶点下标{for(int i = 0;i < G.vexnum;i++) //访问数组初始化visited[i]=0;q.empty();int v;int u;for(v=0;v<G.vexnum;v++)if(!visited[v])//v尚未被访问{visited[v]=1;cout<<G.vertices[v].data<<" ";q.push(v);//V入队列while(!q.empty()){u=q.front();//对头元素出队并置为uq.pop();for(ArcNode *p=G.vertices[v].firstarc;p;p=p->nextarc) if(!visited[p->adjvex])//p为u的尚未访问的邻接节点{visited[p->adjvex]=1;cout<<G.vertices[p->adjvex].data<<" "; q.push(p->adjvex);}//if}//while}//ifreturn 1;}//BFSTraversevoid main(){int a;Create_DG(G);cout<<"输入图深度遍历的起点"<<endl; cin>>a;cout<<"深度优先遍历"<<endl; DFSTraverse(G,a);cout<<endl;cout<<"广度优先遍历"<<endl; BFSTraverse(G);}。

图的遍历算法实验报告图的遍历算法实验报告一、引言图是一种常用的数据结构，用于描述事物之间的关系。

在计算机科学中，图的遍历是一种重要的算法，用于查找和访问图中的所有节点。

本实验旨在探究图的遍历算法，并通过实验验证其正确性和效率。

二、实验目的1. 理解图的基本概念和遍历算法的原理；2. 实现图的遍历算法，并验证其正确性；3. 比较不同遍历算法的效率。

三、实验方法1. 实验环境：使用Python编程语言进行实验；2. 实验步骤：a. 构建图的数据结构，包括节点和边的定义；b. 实现深度优先搜索（DFS）算法；c. 实现广度优先搜索（BFS）算法；d. 验证算法的正确性，通过给定的图进行遍历；e. 比较DFS和BFS的效率，记录运行时间。

四、实验结果1. 图的构建：我们选择了一个简单的无向图作为实验对象，包含6个节点和7条边。

通过邻接矩阵表示图的关系。

```0 1 1 0 0 01 0 1 1 0 01 1 0 0 1 10 1 0 0 0 00 0 1 0 0 00 0 1 0 0 0```2. DFS遍历结果：从节点0开始，遍历结果为0-1-2-4-5-3。

3. BFS遍历结果：从节点0开始，遍历结果为0-1-2-3-4-5。

4. 算法效率比较：我们记录了DFS和BFS算法的运行时间。

经实验发现，在这个图的规模下，DFS算法的运行时间为0.001秒，BFS算法的运行时间为0.002秒。

可以看出，DFS算法相对于BFS算法具有更高的效率。

五、讨论与分析1. 图的遍历算法能够帮助我们了解图中的节点之间的关系，有助于分析和解决实际问题。

2. DFS算法和BFS算法都可以实现图的遍历，但其遍历顺序和效率有所不同。

DFS算法会优先访问深度较大的节点，而BFS算法会优先访问离起始节点最近的节点。

3. 在实验中，我们发现DFS算法相对于BFS算法具有更高的效率。

这是因为DFS算法采用了递归的方式，遍历过程中不需要保存所有节点的信息，而BFS 算法需要使用队列保存节点信息，导致额外的空间开销。

图的遍历实验报告图的遍历实验报告一、引言图是一种常见的数据结构，广泛应用于计算机科学和其他领域。

图的遍历是指按照一定规则访问图中的所有节点。

本实验通过实际操作，探索了图的遍历算法的原理和应用。

二、实验目的1. 理解图的遍历算法的原理；2. 掌握深度优先搜索（DFS）和广度优先搜索（BFS）两种常用的图遍历算法；3. 通过实验验证图的遍历算法的正确性和效率。

三、实验过程1. 实验环境准备：在计算机上安装好图的遍历算法的实现环境，如Python编程环境；2. 实验数据准备：选择合适的图数据进行实验，包括图的节点和边的信息；3. 实验步骤：a. 根据实验数据，构建图的数据结构；b. 实现深度优先搜索算法；c. 实现广度优先搜索算法；d. 分别运行深度优先搜索和广度优先搜索算法，并记录遍历的结果；e. 比较两种算法的结果，分析其异同点；f. 对比算法的时间复杂度和空间复杂度，评估其性能。

四、实验结果与分析1. 实验结果：根据实验数据和算法实现，得到了深度优先搜索和广度优先搜索的遍历结果；2. 分析结果：a. 深度优先搜索：从起始节点出发，一直沿着深度方向遍历，直到无法继续深入为止。

该算法在遍历过程中可能产生较长的路径，但可以更快地找到目标节点，适用于解决一些路径搜索问题。

b. 广度优先搜索：从起始节点出发，按照层次顺序逐层遍历，直到遍历完所有节点。

该算法可以保证找到最短路径，但在遍历大规模图时可能需要较大的时间和空间开销。

五、实验总结1. 通过本次实验，我们深入理解了图的遍历算法的原理和应用；2. 掌握了深度优先搜索和广度优先搜索两种常用的图遍历算法；3. 通过实验验证了算法的正确性和效率；4. 在实际应用中，我们需要根据具体问题的需求选择合适的遍历算法，权衡时间复杂度和空间复杂度；5. 进一步研究和优化图的遍历算法，可以提高算法的性能和应用范围。

六、参考文献[1] Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press.[2] Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley Professional.。

【关键字】实验数据结构图的遍历实验报告篇一：【数据结构】图的保存和遍历实验报告《数据结构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）调试过程中主要遇到哪些问题？是如何解决的？由于实习之初对邻接表的保存结构了解不是很清楚，所以在运行出了一个小错误，即在输出邻接表时，每个结点都少了一个邻接点。

实现图的遍历算法实验报告实现图的遍历算法实验报告⼀实验题⽬: 实现图的遍历算法⼆实验要求:2.1:（1）建⽴如图（p126 8.1）所⽰的有向图 G 的邻接矩阵，并输出之（2）由有向图G的邻接矩阵产⽣邻接表，并输出之（3）再由（2）的邻接表产⽣对应的邻接矩阵，并输出之2.2 （1）输出如图8.1所⽰的有向图G从顶点0开始的深度优先遍历序列（递归算法）（2）输出如图8.1所⽰的有向图G从顶点0开始的深度优先遍历序列（⾮递归算法）（3）输出如图8.1所⽰的有向图G从顶点0开始的⼴度优先遍历序列三实验内容:3.1 图的抽象数据类型:ADT Graph{数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。

数据关系R：R={VR}VR={|v,w∈V且P(v,w)，表⽰从v到w的弧，谓词P(v,w)定义了弧的意义或信息}基本操作：CreateGraph( &G, V, VR )初始条件：V是图的顶点集，VR是图中弧的集合。

操作结果：按V和VR的定义构造图G。

DestroyGraph( &G )初始条件：图G存在。

操作结果：销毁图G。

LocateVex( G, u )初始条件：图G存在，u和G中顶点有相同特征。

操作结果：若G中存在顶点u，则返回该顶点在图中位置；否则返回其它信息。

GetVex( G, v )初始条件：图G存在，v是G中某个顶点。

操作结果：返回v的值。

PutVex( &G, v, value )初始条件：图G存在，v是G中某个顶点。

初始条件：图G存在，v是G中某个顶点。

操作结果：返回v的第⼀个邻接顶点。

若顶点在G中没有邻接顶点，则返回“空”。

NextAdjVex( G, v, w )初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点。

操作结果：返回v的（相对于w的）下⼀个邻接顶点。

若w是v 的最后⼀个邻接点，则返回“空”。

InsertVex( &G, v )初始条件：图G存在，v和图中顶点有相同特征。