图的深度优先遍历实验报告
图论深度优先搜索实验报告
深度优先遍历一、实验目的了解深度优先遍历的基本概念以及实现方式。
二、实验内容1、设计一个算法来对图的进行深度优先遍历；2、用C语言编程来实现此算法。
用下面的实例来调试程序：三、使用环境Xcode编译器四、编程思路深度优先遍历图的方法是，从邻接矩阵出发：访问顶点v；依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；构造一个遍历辅助矩阵visited[]进行比较若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止，并将顶点信息存储在数组Q[]里面。
反复搜索可以通过使用函数的嵌套来实现。
五、调试过程1.程序代码：//为方便调试，程序清晰直观删除了邻接矩阵的构造函数，//并且修改了main()函数，只保留了DFS函数#include <stdio.h>#define N 4 //定义顶点数int a[N][N]={{0,1,1,1},{1,0,0,0},{1,0,0,1},{1,0,0,1}}; //邻接矩阵由之前程序函给出int visited[N]={0}; //遍历比较的辅助矩阵，初始化为0矩阵int Q[N]; //用来存储各个顶点的信息static int last=-1;void DFS(int G[][N], int s){visited[s] = 1;Q[++last]=s;for (int i=0;i<N;i++) //进行遍历{if (G[s][i]==1){if(visited[i] == 0)DFS(G,i); //函数嵌套，完成一次搜索，指向下一个顶点 }}}int main(){DFS(a,0);printf("深度优先搜索为\n");for (int i=0;i<N;i++) //打印遍历的结果printf("%d ",Q[i]+1);return 0;}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同样是一种遍历图的算法，其基本思想是从图的某一顶点开始，首先访问其所有邻接点，然后再依次访问邻接点的邻接点，直到所有顶点都被访问过为止。
2-深度优先遍历以邻接表存储的图-实验报告
《数据结构与关系数据库（本科）》实验报告姓名班级学号实验日期课程名称数据结构与关系数据库（本科）指导教师成绩实验名称：深度优先遍历以邻接表存储的图一、实验目的1、掌握以邻接表存储的图的深度优先遍历算法；二、实验环境1、硬件环境：微机2、软件环境：Windows XP，VC6.0三、实验内容、步骤及结果1、实验内容：基于图的深度优先遍历编写一个算法，判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径（i≠j）。
2、代码：#include <stdio.h>#include <stdlib.h>#define MaxVertexNum 100 /*最大顶点数为100*/typedef char VertexType;typedef struct node{ /*边表结点*/int adjvex; /*邻接点域*/struct node * next; /*指向下一个邻接点的指针域*//*若要表示边上信息，则应增加一个数据域info*/}EdgeNode;typedef struct vnode{ /*顶点表结点*/VertexType vertex; /*顶点域*/EdgeNode * firstedge; /*边表头指针*/}VertexNode;typedef VertexNode AdjList[MaxVertexNum]; /*AdjList 是邻接表类型*/typedef struct{AdjList adjlist; /*邻接表*/int n,e; /*顶点数和边数*/}ALGraph; /*ALGraph 是以邻接表方式存储的图类型*/bool visited[MaxVertexNum];void CreateTestALGraph(ALGraph *G){/*建立有向图的邻接表存储*/int i,j;EdgeNode * s;G->n=8;G->e=9;for (i=0;i<G->n;i++) /*建立有n 个顶点的顶点表*/{G->adjlist[i].vertex='1'+i;//转换为字符型G->adjlist[i].firstedge=NULL; /*顶点的边表头指针设为空*/}{i=0,j=1;s=(EdgeNode*)malloc(sizeof(EdgeNode)); /*生成新边表结点s*/s->adjvex=j; /*邻接点序号为j*/s->next=G->adjlist[i].firstedge; /*将新边表结点s 插入到顶点Vi 的边表头部*/ G->adjlist[i].firstedge=s;i=0,j=2;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; ///*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=1,j=3;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=1,j=4;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=2,j=0;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=2,j=6;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=3,j=4;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;i=4,j=3;s=(EdgeNode*)malloc(sizeof(EdgeNode)); //*生成新边表结点ss->adjvex=j; //*邻接点序号为js->next=G->adjlist[i].firstedge; //*将新边表结点s 插入到顶点Vi 的边表头部G->adjlist[i].firstedge=s;}///*CreateALGraph}void DFSTraverseAL(ALGraph *G){/*深度优先遍历以邻接表存储的图G*/int i;for (i=0;i<G->n;i++)visited[i]=false; /*标志向量初始化*/for (i=0;i<G->n;i++)if (!visited[i]) DFSAL(G,i); /*vi 未访问过，从vi 开始DFS 搜索*/ }/*DFSTraveseAL*///int level=1;//递归进行的层数int exist_path_DFS(ALGraph *G,int i,int j)//深度优先判断有向图G中顶点i到顶点j是否有路径,是则返回1,否则返回0{EdgeNode *p;int k;if(i==j) return 1; //i就是jelse{visited[i]=true;//for(p=G->adjlist[i].firstedge;p;p=p->next,level--)for(p=G->adjlist[i].firstedge;p;p=p->next){//level++;k=p->adjvex;if(!visited[k] && exist_path_DFS(G,k,j)){printf("V%d ",k+1);return 1;//i下游的顶点到j有路径}}//forreturn 0;}//else//if (level==1) return 0;}//exist_path_DFSvoid main(){ALGraph *G;G=(ALGraph *)malloc(sizeof(ALGraph));CreateTestALGraph(G);int i,j;printf("请输入i和j的值格式：i,j\n");scanf("%d,%d",&i,&j);i=i-1;j=j-1;if(i==j){printf("i不能等于j\n");}else{if(exist_path_DFS(G,i,j)){printf("该路径存在。
图的深度和广度遍历-实验报告
实验报告一、实验目的和内容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表示相邻；///对带权图，那么为权值类型。
图的遍历的实验报告
图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构，它由一组节点和连接这些节点的边组成。
图的遍历是指从图中的某个节点出发，按照一定的规则依次访问图中的所有节点。
图的遍历在许多实际问题中都有广泛的应用，例如社交网络分析、路线规划等。
本实验旨在通过实际操作，深入理解图的遍历算法的原理和应用。
二、实验目的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算法需要保存所有已访问过的节点。
深度优先搜索实验报告
深度优先搜索实验报告引言深度优先搜索（Depth First Search，DFS）是图论中的一种重要算法，主要用于遍历和搜索图的节点。
在实际应用中，DFS被广泛用于解决迷宫问题、图的连通性问题等，具有较高的实用性和性能。
本实验旨在通过实际编程实现深度优先搜索算法，并通过实际案例验证其正确性和效率。
实验中我们将以迷宫问题为例，使用深度优先搜索算法寻找从入口到出口的路径。
实验过程实验准备在开始实验之前，我们需要准备一些必要的工具和数据。
1. 编程环境：我们选择使用Python语言进行编程实验，因其语法简洁而强大的数据处理能力。
2. 迷宫地图：我们需要设计一个迷宫地图，包含迷宫的入口和出口，以及迷宫的各个路径和墙壁。
实验步骤1. 首先，我们需要将迷宫地图转化为计算机可处理的数据结构。
我们选择使用二维数组表示迷宫地图，其中0表示墙壁，1表示路径。
2. 接着，我们将编写深度优先搜索算法的实现。
在DFS函数中，我们将使用递归的方式遍历迷宫地图的所有路径，直到找到出口或者遇到墙壁。
3. 在每次遍历时，我们将记录已经访问过的路径，以防止重复访问。
4. 当找到出口时，我们将输出找到的路径，并计算路径的长度。
实验结果经过实验，我们成功地实现了深度优先搜索算法，并在迷宫地图上进行了测试。
以下是我们的实验结果：迷宫地图：1 1 1 1 11 0 0 0 11 1 1 0 11 0 0 0 11 1 1 1 1最短路径及长度：(1, 1) -> (1, 2) -> (1, 3) -> (1, 4) -> (2, 4) -> (3, 4) -> (4, 4) -> (5, 4)路径长度：7从实验结果可以看出，深度优先搜索算法能够准确地找到从入口到出口的最短路径，并输出了路径的长度。
实验分析我们通过本实验验证了深度优先搜索算法的正确性和有效性。
然而，深度优先搜索算法也存在一些缺点：1. 只能找到路径的一种解，不能确定是否为最优解。
数据结构与算法实验报告图的深度优先与广度优先遍历
w=NextAdj(g,v);
}
}
}
void Travel_BFS(源自Node g[],int visited[],int n){
int i;
for(i=0;i<n;i++){
visited[i]=0;
}
for(i=0;i<n;i++){
if(visited[i]==0)
BFS(g,i,visited);
vertexType data;
Arcnode *firstarc;
}VNode;
irstarc=NULL;
}
for(i=0;i<n;i++){
printf("create the edges for the %dth vertex\n",i);
scanf("%d",&e);
while(e!=-1){
二、实验题目与要求
图的遍历
利用邻接矩阵或邻接表作为存储结构建立一个无向图，每个顶点中存放一种水果名(例如apple、orange、banana等，并要求从键盘输入)，顶点数不少于5个。要求分别以深度优先搜索(DFS)和广度优先搜索(BFS)进行遍历，输出遍历结果。
3、源代码清单
=#include<>
p=(Arcnode *)malloc(sizeof(Arcnode));
p->next=NULL;
p->adjvex=e;
if(G[i].firstarc==NULL){
G[i].firstarc=p;
}else{
q->next=p;
}
q=p;
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一．实验目的熟悉图的存储结构，掌握用单链表存储数据元素信息和数据元素之间的关系的信息的方法，并能运用图的深度优先搜索遍历一个图，对其输出。
二．实验原理深度优先搜索遍历是树的先根遍历的推广。
假设初始状态时图中所有顶点未曾访问，则深度优先搜索可从图中某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有与v有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。
图的邻接表的存储表示：#define MAX_VERTEX_NUM 20#define MAXNAME 10typedef char VertexType[MAXNAME];typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{VertexType data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;三．实验内容编写LocateVex函数，Create函数，print函数，main函数，输入要构造的图的相关信息，得到其邻接表并输出显示。
四。
实验步骤1）结构体定义,预定义，全局变量定义。
#include"stdio.h"#include"stdlib.h"#include"string.h"#define FALSE 0#define TRUE 1#define MAX 20typedef int Boolean;#define MAX_VERTEX_NUM 20#define MAXNAME 10typedef char VertexType[MAXNAME];typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{VertexType data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;ALGraph G;Boolean visited[MAX];int degree[MAX_VERTEX_NUM];//定义一个数组求每一个顶点的总度数（无向图）或出度（有向图）。
2）编写LocateVex函数，确定所输入的边在G中的位置，返回该边所在的行数或或列数。
int LocateVex(ALGraph G,VertexType v){int i,n;for(n=0;n<G.vexnum;n++){if(strcmp(v,G.vertices[n].data)==0)i=n;}return i;}3）编写Create函数，采用邻接表构造图G，返回结构体变量G的值，并统计每一个顶点的总度数或出度。
ALGraph Create(ALGraph G){int i,j,k;VertexType v1,v2;ArcNode *p;printf("请输入要构造的图的顶点数和弧数：\n");scanf("%d%d",&G.vexnum,&G.arcnum);printf("请输入每一个顶点的名字：\n");for(i=0;i<G.vexnum;i++){scanf("%s",&G.vertices[i].data);G.vertices[i].firstarc=NULL;}printf("各顶点的位置以及名称为：\n");for(i=0;i<G.vexnum;i++)printf("%6d%6s\n",i,G.vertices[i].data);printf("请输入要构造的是无向图还是有向图：无向用0表示，有向用1表示：\n");scanf("%d",&G.kind);for(i=0;i<G.vexnum;i++)degree[i]=0;printf("请输入每条弧的始点和终点：\n");if(G.kind==1){for(k=0;k<G.arcnum;k++){scanf("%s%s",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;degree[i]++;}}if(G.kind==0){for(k=0;k<G.arcnum;k++){scanf("%s%s",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;degree[i]++;p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=i;p->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p;degree[j]++;}}return G;}4）编写print函数，实现对所构建的图的邻接表的输出。
void print(ALGraph G){int i;ArcNode *p;for(i=0;i<G.vexnum;i++){printf("%6d%6s",i,G.vertices[i].data);for(p=G.vertices[i].firstarc;p;p=p->nextarc) printf("%6d",p->adjvex);printf("\n");if(G.kind==1)printf("出度为：%6d\n",degree[i]);if(G.kind==0)printf("总度数为：%6d\n",degree[i]);}}5）编写FirstAdjVex函数，返回v的第一个邻接点的编号。
int FirstAdjVex(ALGraph G,int v){ArcNode *p;p=G.vertices[v].firstarc;if(p)return(p->adjvex);elsereturn -1;}6）编写NextAdjVex函数，返回v第一个之后未被访问过的下一个邻接点。
int NextAdjVex(ALGraph G,int v,int w){ArcNode *p;int i;for(p=G.vertices[v].firstarc;p;p=p->nextarc){if(w!=p->adjvex)i=0;else i=1;if(i&&p)return p->nextarc->adjvex;elsereturn -1;}}7）编写DFS函数，从第i个顶点出发递归地深度优先遍历图G。
void DFS(ALGraph G,int v){int w;visited[v]=TRUE;printf("%s\n",G.vertices[v].data);for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) if(!visited[w])DFS(G,w);}8）编写DFSTraverse函数，对图G作深度优先遍历。
void DFSTraverse(ALGraph G){int v;for(v=0;v<G.vexnum;++v)visited[v]=FALSE;for(v=0;v<G.vexnum;++v)if(!visited[v])DFS(G,v);}9）编写main函数，把以上几个函数结合到一起，用邻接表实现对一个图的构造，输入要构造的边的相关信息（总弧数，顶点数，边的两个顶点的名称，有向图还是无向图），对其进行输出显示，并用深度优先搜索的方法遍历所构建的图。
main(){ALGraph G;G=Create(G);printf("邻接表为：\n");print(G);printf("深度遍历的结果为：\n");DFSTraverse(G);}五．实验结果源程序代码：#include"stdio.h"#include"stdlib.h"#include"string.h"#define FALSE 0#define TRUE 1#define MAX 20typedef int Boolean;#define MAX_VERTEX_NUM 20#define MAXNAME 10typedef char VertexType[MAXNAME]; typedef struct ArcNode{int adjvex;struct ArcNode *nextarc;}ArcNode;typedef struct VNode{VertexType data;ArcNode *firstarc;}VNode,AdjList[MAX_VERTEX_NUM]; typedef struct{AdjList vertices;int vexnum,arcnum;int kind;}ALGraph;ALGraph G;Boolean visited[MAX];int degree[MAX_VERTEX_NUM];int LocateVex(ALGraph G,VertexType v) {int i,n;for(n=0;n<G.vexnum;n++){if(strcmp(v,G.vertices[n].data)==0)i=n;}return i;}ALGraph Create(ALGraph G){int i,j,k;VertexType v1,v2;ArcNode *p;printf("请输入要构造的图的顶点数和弧数：\n");scanf("%d%d",&G.vexnum,&G.arcnum);printf("请输入每一个顶点的名字：\n");for(i=0;i<G.vexnum;i++){scanf("%s",&G.vertices[i].data);G.vertices[i].firstarc=NULL;}printf("各顶点的位置以及名称为：\n");for(i=0;i<G.vexnum;i++)printf("%6d%6s\n",i,G.vertices[i].data);printf("请输入要构造的是无向图还是有向图：无向用0表示，有向用1表示：\n");scanf("%d",&G.kind);for(i=0;i<G.vexnum;i++)degree[i]=0;printf("请输入每条弧的始点和终点：\n");if(G.kind==1){for(k=0;k<G.arcnum;k++){scanf("%s%s",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;degree[i]++;}}if(G.kind==0){for(k=0;k<G.arcnum;k++){scanf("%s%s",&v1,&v2);i=LocateVex(G,v1);j=LocateVex(G,v2);p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;degree[i]++;p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=i;p->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p;degree[j]++;}}return G;}void print(ALGraph G){int i;ArcNode *p;for(i=0;i<G.vexnum;i++){printf("%6d%6s",i,G.vertices[i].data);for(p=G.vertices[i].firstarc;p;p=p->nextarc)printf("%6d",p->adjvex);printf("\n");if(G.kind==1)printf("出度为：%6d\n",degree[i]);if(G.kind==0)printf("总度数为：%6d\n",degree[i]);}}int FirstAdjVex(ALGraph G,int v){ArcNode *p;p=G.vertices[v].firstarc;if(p)return(p->adjvex);elsereturn -1;}int NextAdjVex(ALGraph G,int v,int w){ArcNode *p;int i;for(p=G.vertices[v].firstarc;p;p=p->nextarc){if(w!=p->adjvex)i=0;else i=1;if(i&&p)return p->nextarc->adjvex;elsereturn -1;}}void DFS(ALGraph G,int v){int w;visited[v]=TRUE;printf("%s\n",G.vertices[v].data);for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) if(!visited[w])DFS(G,w);}void DFSTraverse(ALGraph G){int v;for(v=0;v<G.vexnum;++v)visited[v]=FALSE;for(v=0;v<G.vexnum;++v)if(!visited[v])DFS(G,v);}main(){ALGraph G;G=Create(G);printf("邻接表为：\n");print(G);printf("深度遍历的结果为：\n");DFSTraverse(G);}构造一个无向图G，如图所示。