图的深度和广度遍历-实验报告
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法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. 理解和掌握图的遍历算法的原理与实现；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）的实现方法，加深对数据结构中图的理解。
二、实验步骤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同样是一种遍历图的算法，其基本思想是从图的某一顶点开始，首先访问其所有邻接点，然后再依次访问邻接点的邻接点，直到所有顶点都被访问过为止。
数据结构实验报告-图的遍历
数据结构实验报告实验：图的遍历一、实验目的：1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表2、掌握图的构造方法3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法4、掌握图的深度优先遍历和广度优先原理二、实验内容：1、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接矩阵存储改图。
2、输入顶点数、边数、每个顶点的值以及每一条边的信息，构造一个无向图G，并用邻接表存储该图3、深度优先遍历第一步中构造的图G，输出得到的节点序列4、广度优先遍历第一部中构造的图G，输出得到的节点序列三、实验要求：1、无向图中的相关信息要从终端以正确的方式输入；2、具体的输入和输出格式不限；3、算法要具有较好的健壮性，对错误操作要做适当处理；4、程序算法作简短的文字注释。
四、程序实现及结果：1、邻接矩阵：#include <stdio.h>#include <malloc.h>#define VERTEX_MAX 30#define MAXSIZE 20typedef struct{intarcs[VERTEX_MAX][VERTEX_MAX] ;int vexnum,arcnum;} MGraph; void creat_MGraph1(MGraph *g) { int i,j,k;int n,m;printf("请输入顶点数和边数:");scanf("%d%d",&n,&m);g->vexnum=n;g->arcnum=m;for (i=0;i<n;i++)for (j=0;j<n;j++)g->arcs[i][j]=0;while(1){printf("请输入一条边的两个顶点：\n");scanf("%d%d",&i,&j);if(i==-1 || j==-1)break;else if(i==j || i>=n || j>=n){printf("输入错误,请重新输入！\n");}else{g->arcs[i][j]=1;g->arcs[j][i]=1;}}}void printMG(MGraph *g) {int i,j;for (i=0;i<g->vexnum;i++){for (j=0;j<g->vexnum;j++)printf(" %d",g->arcs[i][j]);printf("\n");}printf("\n");}main(){int i,j;int fg;MGraph *g1;g1=(MGraph*)malloc(sizeof(MGraph));printf("1:创建无向图的邻接矩阵\n\n");creat_MGraph1(g1);printf("\n此图的邻接矩阵为：\n"); printMG(g1);}2、邻接链表:#include<stdio.h>#include<malloc.h>#define MAX_SIZE 10typedef struct node{int vertex;struct node *next;}node,adjlist[MAX_SIZE];adjlist g;int visited[MAX_SIZE+1];int que[MAX_SIZE+1];void creat(){int n,e;int i;int start,end;node *p,*q,*pp,*qq;printf("输入无向图的顶点数和边数:");scanf("%d%d",&n,&e);for(i = 1; i <= n ; i++){visited[i] = 0;g[i].vertex = i;g[i].next = NULL;}printf("依次输入边:\n");for(i = 1; i <= e ; i++){scanf("%d%d",&start,&end);p=(node *)malloc(sizeof(node));p->vertex = end;p->next = NULL;q = &g[start];while(q->next)q = q->next;q->next = p;p1=(node*)malloc(sizeof(node));p1->vertex = start;p1->next = NULL;q1 = &g[end];while(qq->next)q1 = q1->next;q1->next = p1;}}void bfs(int vi){int front,rear,v;node *p;front =0;rear = 1;visited[vi] = 1;que[0] = vi;printf("%d ",vi);while(front != rear){v = que[front];p = g[v].next;while(p){if(!visited[p->vertex]){visited[p->vertex]= 1;printf("%d",p->vertex);que[rear++] = p->vertex;}p = p->next;}front++;}}int main(){creat();bfs(1);printf("\n");return 0;}五．实验心得与体会：(1)通过这次实验，使我基本上掌握了图的存储和遍历，让我弄清楚了如何用邻接矩阵和邻接链表对图进行存储(2)深度优先遍历和广度优先遍历都有着各自的优点，通过程序逐步调试，可以慢慢的理解这两种遍历方法的内涵和巧妙之处。
图的遍历的实验报告
图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构，它由一组节点和连接这些节点的边组成。
图的遍历是指从图中的某个节点出发，按照一定的规则依次访问图中的所有节点。
图的遍历在许多实际问题中都有广泛的应用，例如社交网络分析、路线规划等。
本实验旨在通过实际操作，深入理解图的遍历算法的原理和应用。
二、实验目的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. 掌握深度优先搜索（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.。
广度遍历的实验报告(3篇)
第1篇一、实验目的1. 理解广度遍历的基本概念和原理；2. 掌握广度遍历算法的编程实现；3. 熟悉图的邻接表表示方法；4. 分析广度遍历算法在图中的应用。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验原理广度遍历（Breadth-First Search，BFS）是一种基于图的遍历算法，它按照顶点的层次顺序访问图中的所有顶点。
具体来说，从起始顶点开始，首先访问起始顶点，然后访问起始顶点的所有邻接顶点，接着访问邻接顶点的邻接顶点，以此类推，直到遍历完所有顶点。
广度遍历算法通常采用队列数据结构来实现。
在遍历过程中，首先将起始顶点入队，然后从队列中依次取出顶点，访问其邻接顶点，并将邻接顶点入队。
这样，每个顶点都会按照其被访问的顺序入队，从而实现了广度遍历。
四、实验步骤1. 创建图：使用邻接表表示法创建实验所需的图。
2. 实现广度遍历算法：编写广度遍历算法的代码，实现图的遍历功能。
3. 运行实验：运行实验程序，观察广度遍历算法的执行过程和结果。
五、实验代码```cppinclude <iostream>include <vector>include <queue>using namespace std;// 定义图的结构体struct Graph {int numVertices; // 顶点数量vector<int> adjList; // 邻接表};// 初始化图void initGraph(Graph &g, int numVertices) {g.numVertices = numVertices;g.adjList.resize(numVertices);}// 添加边void addEdge(Graph &g, int src, int dest) {g.adjList[src].push_back(dest);}// 广度遍历void bfs(Graph &g, int startVertex) {queue<int> queue;vector<bool> visited(g.numVertices, false); // 访问标记数组 // 将起始顶点入队queue.push(startVertex);visited[startVertex] = true;while (!queue.empty()) {int vertex = queue.front();cout << "访问顶点: " << vertex << endl; queue.pop();// 遍历邻接顶点for (int neighbor : g.adjList[vertex]) { if (!visited[neighbor]) {queue.push(neighbor);visited[neighbor] = true;}}}}int main() {// 创建图Graph g;initGraph(g, 6);addEdge(g, 0, 1);addEdge(g, 0, 2);addEdge(g, 1, 3);addEdge(g, 1, 4);addEdge(g, 2, 5);addEdge(g, 3, 5);addEdge(g, 4, 5);// 广度遍历cout << "广度遍历结果：" << endl;bfs(g, 0);return 0;}```六、实验结果与分析运行实验程序，可以得到以下输出：```访问顶点: 0访问顶点: 1访问顶点: 2访问顶点: 3访问顶点: 4访问顶点: 5```从输出结果可以看出，广度遍历算法按照顶点的层次顺序访问了图中的所有顶点，符合预期。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告一、实验目的和内容1.实验目的掌握图的邻接矩阵的存储构造；实现图的两种遍历：深度优先遍历和广度优先遍历。
2.实验内容1．图的初始化；2．图的遍历：深度优先遍历和广度优先遍历。
二、实验方案程序主要代码：///<summary>///邻接矩阵的节点数据///</summary>public struct ArcCell{public int Type; //顶点的关系类型，对无权图，用1或0表示相邻；//对带权图，那么为权值类型。
public object Data; //该弧相关信息public ArcCell(int type,object data){Type = type;Data = data;}}///<summary>///图的类型///</summary>public enum GKind {DG,DN,UDG,UDN}; //有向图，有向网，无向图，无向网///<summary>///图类///</summary>public class Graph{public static int Max_Vertex_Num = 20; //最大顶点数private object [] Vexs; //顶点数据数组private ArcCell [,] Arcs; //邻接矩阵private GKind Kind; //图的种类private int VexNum,ArcNum; //当前顶点数和弧数///<summary>///图的初始化方法///</summary>///<param name="vexnum">顶点数</param>///<param name="arcnum">弧数</param>///<param name="k">图的类型</param>public Graph(int vexnum,int arcnum,GKind k){VexNum = vexnum;ArcNum = arcnum;Kind = k;Vexs = new object[Max_Vertex_Num];Arcs = new ArcCell[Max_Vertex_Num,Max_Vertex_Num];}///<summary>///设置v1，v2之间的弧的权值，顶点的关系类型，对无权图，用1或0表示相邻；///对带权图，那么为权值类型。
///</summary>///<param name="v1">顶点1</param>///<param name="v2">顶点2</param>///<param name="adj">权</param>///<returns>成功返回真，否那么返回假</returns>public bool SetArcInfo(int v1,int v2,int adj,object data){if(v1<VexNum && v2<VexNum){Arcs[v1,v2].Type = adj;Arcs[v1,v2].Data = data;switch(Kind){case GKind.DG:break;case GKind.UDG:Arcs[v2,v1].Type = adj;Arcs[v2,v1].Data = data;break;case GKind.DN:break;case GKind.UDN:break;}return true;}elsereturn false;}///<summary>///设置指定顶点的信息///</summary>///<param name="v">顶点号</param>///<param name="info">要设置的信息</param>///<returns>成功返回真，否那么返回假</returns>public bool SetVexInfo(int v,object info){if(v<VexNum){Vexs[v] = info;return true;}elsereturn false;}///<summary>///返回v的第一个邻接顶点，假设没有那么返回-1///</summary>public int FirstAdjVex(int v){for(int j=0;j<this.VexNum;j++){if((this.Arcs[v,j].Type>0)&&(this.Arcs[v,j].Type<int.MaxValue)) {return j;}}return -1;}//指定节点vex的(相对于Fvex)下一个邻接顶点，假设没有那么返回-1public int NextAdjVex(int vex,int Fvex){for(int j=0;j<this.VexNum;j++){if((this.Arcs[vex,j].Type>0)&&(this.Arcs[vex,j].Type<int.MaxValue )&&(j>Fvex)){return j;}}return -1;}public static bool [] visited; //访问标志数组///<summary>///深度遍历，递归算法///</summary>public string DFSTraverse(){visited = new bool[this.VexNum]; //初始化访问标志数组string str ="";for(int v=0;v<this.VexNum;v++){visited[v] = false;}for(int v=0;v<this.VexNum;v++){if(!visited[v])str +=DFS(v);}return str;}///<summary>///从第v个顶点出发递归地深度优先遍历///</summary>public string DFS(int v){string str ="";visited[v] = true;str +=" "+ this.Vexs[v];for(int i=FirstAdjVex(v);i>=0;i=NextAdjVex(v,i))if(!visited[i])str +=DFS(i);return str;}///<summary>///深度优先遍历，非递归算法///</summary>public string DFSTrav(){visited = new bool[this.VexNum]; //初始化访问标志数组string str ="";for(int v=0;v<this.VexNum;v++){visited[v] = false;}new Stack(); //初始化辅助栈for(int v=0;v<this.VexNum;v++) //可以遍历多个散图{if(!visited[v]){visited[v] = true;str +=" "+this.Vexs[v];st.Push(v); //v入栈while(st.Count>0){int u = (int)st.Pop();for(int w=FirstAdjVex(u);w>=0;w=NextAdjVex(u,w)){if(!visited[w]){visited[w] = true;str +=" "+this.Vexs[w];st.Push(w);break;}}}}}return str;}///<summary>///广度优先遍历，非递归算法///</summary>public string BFSTraverse(){visited = new bool[this.VexNum]; //初始化访问标志数组string str ="";for(int v=0;v<this.VexNum;v++){visited[v] = false;}new Queue(); //初始化辅助队列for(int v=0;v<this.VexNum;v++) //可以遍历多个散图{if(!visited[v]){visited[v] = true;str +=" "+this.Vexs[v];Q.Enqueue(v); //v入队列while(Q.Count>0){int u = (int)Q.Dequeue();for(int w=FirstAdjVex(u);w>=0;w=NextAdjVex(u,w)){if(!visited[w]){visited[w] = true;str +=" "+this.Vexs[w];Q.Enqueue(w);}}}}}return str;}///<summary>///显示邻接矩阵///</summary>public string Display(){string graph = "";for(int i=0;i<this.VexNum;i++){for(int j=0;j<this.ArcNum;j++){graph +=" "+ this.Arcs[i,j].Type;}graph +="\n";}return graph;}}///<summary>///应用程序的主入口点。
///</summary>[STAThread]static void Main(string[] args){string a="";while(true){Graph g = new Graph(8,9,GKind.UDG);g.SetArcInfo(0,1,1,0);g.SetArcInfo(0,2,1,0);g.SetArcInfo(1,3,1,0);g.SetArcInfo(1,4,1,0);g.SetArcInfo(2,5,1,0);g.SetArcInfo(2,6,1,0);g.SetArcInfo(3,7,1,0);g.SetArcInfo(4,7,1,0);g.SetArcInfo(5,6,1,0);g.SetVexInfo(0,"V1");g.SetVexInfo(1,"V2");g.SetVexInfo(2,"V3");g.SetVexInfo(3,"V4");g.SetVexInfo(4,"V5");g.SetVexInfo(5,"V6");g.SetVexInfo(6,"V7");g.SetVexInfo(7,"V8");顶点，9弧无向图的邻接矩阵：\n");深度优先遍历(递归算法)：\n");深度优先遍历(非递归算法)：\n");广度优先遍历(非递归算法)：\n");输入：exit ，退出程序");if(a =="exit")break;if(a.Trim().Length ==0 )continue;}}三、实验数据、结果分析程序运行结果：图如下：理论结果如下：深度优先遍历：V1 –> V2 -> V4 -> V8 -> V5 -> V3 -> V6 -> V7 广度优先遍历：V1 –> V2 -> V3 -> V4 -> V5 -> V6 -> V7 -> V8实验结果与理论结果一致。