数据结构图的遍历
数据结构实验报告图的遍历讲解
数据结构实验报告图的遍历讲解一、引言在数据结构实验中，图的遍历是一个重要的主题。
图是由顶点集合和边集合组成的一种数据结构，常用于描述网络、社交关系等复杂关系。
图的遍历是指按照一定的规则，挨次访问图中的所有顶点，以及与之相关联的边的过程。
本文将详细讲解图的遍历算法及其应用。
二、图的遍历算法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表示边的数量。
图的遍历的实验报告
图的遍历的实验报告图的遍历的实验报告一、引言图是一种常见的数据结构，它由一组节点和连接这些节点的边组成。
图的遍历是指从图中的某个节点出发，按照一定的规则依次访问图中的所有节点。
图的遍历在许多实际问题中都有广泛的应用，例如社交网络分析、路线规划等。
本实验旨在通过实际操作，深入理解图的遍历算法的原理和应用。
二、实验目的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算法需要保存所有已访问过的节点。
数据结构课设——有向图的深度、广度优先遍历及拓扑排序
数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。
功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。
按照惯例，先上代码，注释超详细：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#pragma warning(disable:4996)#define Max 20//定义数组元素最⼤个数（顶点最⼤个数）typedef struct node//边表结点{int adjvex;//该边所指向结点对应的下标struct node* next;//该边所指向下⼀个结点的指针}eNode;typedef struct headnode//顶点表结点{int in;//顶点⼊度char vertex;//顶点数据eNode* firstedge;//指向第⼀条边的指针，边表头指针}hNode;typedef struct//邻接表（图）{hNode adjlist[Max];//以数组的形式存储int n, e;//顶点数，边数}linkG;//以邻接表的存储结构创建图linkG* creat(linkG* g){int i, k;eNode* s;//边表结点int n1, e1;char ch;g = (linkG*)malloc(sizeof(linkG));//申请结点空间printf("请输⼊顶点数和边数：");scanf("%d%d", &n1, &e1);g->n = n1;g->e = e1;printf("顶点数：%d 边数：%d\n", g->n, g->e);printf("请输⼊顶点信息（字母）：");getchar();//因为接下来要输⼊字符串，所以getchar⽤于承接上⼀条命令的结束符for (i = 0; i < n1; i++){scanf("%c", &ch);g->adjlist[i].vertex = ch;//获得该顶点数据g->adjlist[i].firstedge = NULL;//第⼀条边设为空}printf("\n打印顶点下标及顶点数据：\n");for (i = 0; i < g->n; i++)//循环打印顶点下标及顶点数据{printf("顶点下标：%d 顶点数据：%c\n", i, g->adjlist[i].vertex);}getchar();int i1, j1;//相连接的两个顶点序号for (k = 0; k < e1; k++)//建⽴边表{printf("请输⼊对<i,j>（空格分隔）：");scanf("%d%d", &i1, &j1);s = (eNode*)malloc(sizeof(eNode));//申请边结点空间s->adjvex = j1;//边所指向结点的位置，下标为j1s->next = g->adjlist[i1].firstedge;//将当前s的指针指向当前顶点上指向的结点g->adjlist[i1].firstedge = s;//将当前顶点的指针指向s}return g;//返回指针g}int visited[Max];//标记是否访问void DFS(linkG* g, int i)//深度优先遍历{eNode* p;printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已访问过的顶点visited值改为1p = g->adjlist[i].firstedge;//p指向顶点i的第⼀条边while (p)//p不为NULL时（边存在）{if (visited[p->adjvex] != 1)//如果没有被访问DFS(g, p->adjvex);//递归}p = p->next;//p指向下⼀个结点}}void DFSTravel(linkG* g)//遍历⾮连通图{int i;printf("深度优先遍历;\n");//printf("%d\n",g->n);for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问{DFS(g, i);//调⽤DFS函数}}}void BFS(linkG* g, int i)//⼴度优先遍历{int j;eNode* p;int q[Max], front = 0, rear = 0;//建⽴顺序队列⽤来存储，并初始化printf("%c ", g->adjlist[i].vertex);visited[i] = 1;//将已经访问过的改成1rear = (rear + 1) % Max;//普通顺序队列的话，这⾥是rear++q[rear] = i;//当前顶点（下标）队尾进队while (front != rear)//队列⾮空{front = (front + 1) % Max;//循环队列，顶点出队j = q[front];p = g->adjlist[j].firstedge;//p指向出队顶点j的第⼀条边while (p != NULL){if (visited[p->adjvex] == 0)//如果未被访问{printf("%c ", g->adjlist[p->adjvex].vertex);visited[p->adjvex] = 1;//将该顶点标记数组值改为1rear = (rear + 1) % Max;//循环队列q[rear] = p->adjvex;//该顶点进队}p = p->next;//指向下⼀个结点}}}void BFSTravel(linkG* g)//遍历⾮连通图{int i;printf("⼴度优先遍历：\n");for (i = 0; i < g->n; i++)//初始化为0{visited[i] = 0;}for (i = 0; i < g->n; i++)//对每个顶点做循环{if (!visited[i])//如果没有被访问过{BFS(g, i);//调⽤BFS函数}}}//因为拓扑排序要求⼊度为0，所以需要先求出每个顶点的⼊度void inDegree(linkG* g)//求图顶点⼊度{eNode* p;int i;for (i = 0; i < g->n; i++)//循环将顶点⼊度初始化为0{g->adjlist[i].in = 0;}for (i = 0; i < g->n; i++)//循环每个顶点{p = g->adjlist[i].firstedge;//获取第i个链表第1个边结点指针while (p != NULL)///当p不为空（边存在）{g->adjlist[p->adjvex].in++;//该边终点结点⼊度+1p = p->next;//p指向下⼀个边结点}printf("顶点%c的⼊度为：%d\n", g->adjlist[i].vertex, g->adjlist[i].in);}void topo_sort(linkG *g)//拓扑排序{eNode* p;int i, k, gettop;int top = 0;//⽤于栈指针的下标索引int count = 0;//⽤于统计输出顶点的个数int* stack=(int *)malloc(g->n*sizeof(int));//⽤于存储⼊度为0的顶点for (i=0;i<g->n;i++)//第⼀次搜索⼊度为0的顶点{if (g->adjlist[i].in==0){stack[++top] = i;//将⼊度为0的顶点进栈}}while (top!=0)//当栈不为空时{gettop = stack[top--];//出栈,并保存栈顶元素（下标）printf("%c ",g->adjlist[gettop].vertex);count++;//统计顶点//接下来是将邻接点的⼊度减⼀，并判断该点⼊度是否为0p = g->adjlist[gettop].firstedge;//p指向该顶点的第⼀条边的指针while (p)//当p不为空时{k = p->adjvex;//相连接的顶点（下标）g->adjlist[k].in--;//该顶点⼊度减⼀if (g->adjlist[k].in==0){stack[++top] = k;//如果⼊度为0，则进栈}p = p->next;//指向下⼀条边}}if (count<g->n)//如果输出的顶点数少于总顶点数，则表⽰有环{printf("\n有回路！\n");}free(stack);//释放空间}void menu()//菜单{system("cls");//清屏函数printf("************************************************\n");printf("* 1.建⽴图 *\n");printf("* 2.深度优先遍历 *\n");printf("* 3.⼴度优先遍历 *\n");printf("* 4.求出顶点⼊度 *\n");printf("* 5.拓扑排序 *\n");printf("* 6.退出 *\n");printf("************************************************\n");}int main(){linkG* g = NULL;int c;while (1){menu();printf("请选择：");scanf("%d", &c);switch (c){case1:g = creat(g); system("pause");break;case2:DFSTravel(g); system("pause");break;case3:BFSTravel(g); system("pause");break;case4:inDegree(g); system("pause");break;case5:topo_sort(g); system("pause");break;case6:exit(0);break;}}return0;}实验⽤图:运⾏结果：关于深度优先遍历 a.从图中某个顶点v 出发，访问v 。
图的遍历算法实验报告
图的遍历算法实验报告图的遍历算法实验报告一、引言图是一种常用的数据结构，用于描述事物之间的关系。
在计算机科学中，图的遍历是一种重要的算法，用于查找和访问图中的所有节点。
本实验旨在探究图的遍历算法，并通过实验验证其正确性和效率。
二、实验目的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 算法需要使用队列保存节点信息，导致额外的空间开销。
dfs和bfs的遍历方法
dfs和bfs的遍历方法DFS和BFS的遍历方法一、引言在计算机科学中，图是一种非常重要的数据结构。
图由节点（顶点）和边组成，节点表示对象，边表示节点之间的关系。
图可以用来解决很多实际问题，例如路线规划、社交网络分析等。
在图的遍历中，DFS（深度优先搜索）和BFS（广度优先搜索）是两种常用的方法。
它们分别从图中的一个节点出发，按照不同的顺序遍历图中的所有节点。
本文将详细介绍DFS和BFS的遍历方法，包括其原理、算法实现和应用场景。
二、DFS的遍历方法DFS是一种先序遍历的方法，其基本原理是从图中的一个节点开始，沿着一条路径尽可能深地遍历，直到无法继续深入为止，然后回溯到上一个节点，选择另一条路径继续遍历，直到所有节点都被访问过为止。
DFS的算法实现可以使用递归或者栈。
下面是使用递归实现DFS的伪代码：```function DFS(node):if node is visited:returnvisit(node)mark node as visitedfor each adjacent node of node:DFS(adjacent node)```在DFS的遍历过程中，需要一个visited数组用于记录节点是否被访问过，避免重复访问。
DFS的时间复杂度为O(V+E)，其中V为节点数，E为边数。
DFS的应用场景包括图的连通性判断、拓扑排序等。
例如，在社交网络中，可以使用DFS遍历用户之间的关系，找出两个用户之间的最短路径。
三、BFS的遍历方法BFS是一种层次遍历的方法，其基本原理是从图中的一个节点开始，先访问其所有的邻居节点，然后再依次访问邻居节点的邻居节点，直到所有节点都被访问过为止。
BFS的算法实现可以使用队列。
下面是使用队列实现BFS的伪代码：```function BFS(start_node):create an empty queueenqueue start_node into the queuemark start_node as visitedwhile the queue is not empty:current_node = dequeue from the queuevisit(current_node)for each adjacent node of current_node:if adjacent node is not visited:mark adjacent node as visitedenqueue adjacent node into the queue```在BFS的遍历过程中，同样需要一个visited数组用于记录节点是否被访问过。
图的遍历算法实验报告
图的遍历算法实验报告
《图的遍历算法实验报告》
在计算机科学领域，图的遍历算法是一种重要的算法，它用于在图数据结构中
访问每个顶点和边。
图的遍历算法有两种常见的方法：深度优先搜索（DFS）
和广度优先搜索（BFS）。
在本实验中，我们将对这两种算法进行实验，并比较
它们的性能和应用场景。
首先，我们使用深度优先搜索算法对一个简单的无向图进行遍历。
通过实验结
果可以看出，DFS算法会首先访问一个顶点的所有邻居，然后再递归地访问每
个邻居的邻居，直到图中所有的顶点都被访问到。
这种算法在一些应用场景中
非常有效，比如寻找图中的连通分量或者寻找图中的环路。
接下来，我们使用广度优先搜索算法对同样的无向图进行遍历。
通过实验结果
可以看出，BFS算法会首先访问一个顶点的所有邻居，然后再按照距离递增的
顺序访问每个邻居的邻居。
这种算法在一些应用场景中也非常有效，比如寻找
图中的最短路径或者寻找图中的最小生成树。
通过对比实验结果，我们可以发现DFS和BFS算法各自的优势和劣势。
DFS算
法适合用于寻找图中的连通分量和环路，而BFS算法适合用于寻找最短路径和
最小生成树。
因此，在实际应用中，我们需要根据具体的需求来选择合适的算法。
总的来说，图的遍历算法是计算机科学中非常重要的算法之一，它在许多领域
都有着广泛的应用。
通过本次实验，我们对DFS和BFS算法有了更深入的了解，并且对它们的性能和应用场景有了更清晰的认识。
希望通过这篇实验报告，读
者们也能对图的遍历算法有更深入的理解和认识。
图的遍历数据结构实验报告
图的遍历数据结构实验报告正文：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）的所有节点线性排序的算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include"stdlib.h"#include"stdio.h"#include"malloc.h"#define INFINITY 32767#define MAX_VERTEX_NUM 20typedef enum{FALSE,TRUE}visited_hc;typedef enum{DG,DN,UDG,UDN}graphkind_hc;typedef struct arccell_hc{int adj;int*info;}arccell_hc,adjmatrix_hc[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{char vexs[MAX_VERTEX_NUM];adjmatrix_hc arcs;int vexnum,arcnum;graphkind_hc kind;}mgraph_hc;typedef struct arcnode_hc{int adjvex;struct arcnode_hc *nextarc;int*info;}arcnode_hc;typedef struct vnode_hc{char data;arcnode_hc *firstarc;}vnode_hc,adjlist_hc[MAX_VERTEX_NUM];typedef struct{adjlist_hc vertices;int vexnum,arcnum;graphkind_hc kind;}algraph_hc;int locatevex_hc(mgraph_hc*g,char v){int i,k=0;for(i=0;i<g->vexnum;i++)if(g->vexs[i]==v){k=i;i=g->vexnum;}return(k);}mgraph_hc*createudg_hc(){mgraph_hc*g;char v1,v2;int i,j,incinfo;g=(mgraph_hc*)malloc(sizeof(mgraph_hc));g->kind=UDG;printf("请输入图顶点数、边数及该边相关信息:"); scanf("%d %d %d",&g->vexnum,&g->arcnum,&incinfo); printf("请输入顶点信息:");flushall();for(i=0;i<g->vexnum;++i)scanf("%c",&g->vexs[i]);for(i=0;i<g->vexnum;++i)for(j=0;j<g->vexnum;++j)g->arcs[i][j].adj=0;printf("输入一条边依附的顶点:\n");flushall();scanf("%c%c",&v1,&v2);while(v1!='#'&&v2!='#'){i=locatevex_hc(g,v1);j=locatevex_hc(g,v2);g->arcs[i][j].adj=1;if(incinfo)g->arcs[i][j].info=&incinfo;g->arcs[j][i].adj=g->arcs[i][j].adj;g->arcs[j][i].info=g->arcs[i][j].info;flushall();scanf("%c%c",&v1,&v2);}return(g);}visited_hc vis[MAX_VERTEX_NUM];int firstadjvex_hc(mgraph_hc*g,int v){int i,k=-1;for(i=0;i<g->vexnum;i++)if(g->arcs[v][i].adj==1){k=i;i=g->vexnum;}return(k);}int nextadjvex_hc(mgraph_hc*g,int v,int w){int i,k=-1;for(i=0;i<g->vexnum;i++)if(g->arcs[v][i].adj==1&&i>w){k=i;i=g->vexnum;} return(k);}void dfs_hc(mgraph_hc*g,int v){int w;vis[v]=TRUE; printf("%c",g->vexs[v]);for(w=firstadjvex_hc(g,v);w>=0;w=nextadjvex_hc(g,v,w)) if(!vis[w])dfs_hc(g,w);}void dfstraverse_hc(mgraph_hc*g){int v,i;char f;for(v=0;v<g->vexnum;v++)vis[v]=FALSE;printf("输入遍历开始顶点:");flushall();scanf("%c",&f);i=locatevex_hc(g,f);printf("深度遍历结果为:");for(v=i;v<g->vexnum;v++)if(!vis[v])dfs_hc(g,v);for(v=0;v<i;v++)if(!vis[v])dfs_hc(g,v);}int locatevexal_hc(algraph_hc*a,char v){int i,k=0;for(i=0;i<a->vexnum;i++)if(a->vertices[i].data==v){k=i;i=a->vexnum;}return(k);}char createlist_hc(algraph_hc*a,arcnode_hc*firstl,char v) {arcnode_hc*nextl;if(v!='\n'){nextl=(arcnode_hc*)malloc(sizeof(arcnode_hc));nextl->adjvex=locatevexal_hc(a,v);nextl->nextarc=NULL;nextl->info=firstl->info;firstl->nextarc=nextl;scanf("%c",&v);v=createlist_hc(a,nextl,v);}return(v);}algraph_hc*createaludg_hc(){algraph_hc*a;int i,incinfo;char v;a=(algraph_hc*)malloc(sizeof(algraph_hc));a->kind=UDG;printf("请输入图顶点数、边数及该边相关信息:");scanf("%d %d %d",&a->vexnum,&a->arcnum,&incinfo);printf("请输入顶点信息:");flushall();for(i=0;i<a->vexnum;++i)scanf("%c",&a->vertices[i].data);for(i=0;i<a->vexnum;++i){printf("输入%c的邻接点:",a->vertices[i].data);flushall();scanf("%c",&v);a->vertices[i].firstarc=(arcnode_hc*)malloc(sizeof(arcnode_hc)); a->vertices[i].firstarc->adjvex=locatevexal_hc(a,v);a->vertices[i].firstarc->nextarc=NULL;if(incinfo)a->vertices[i].firstarc->info=&incinfo;scanf("%c",&v);v=createlist_hc(a,a->vertices[i].firstarc,v);} return(a);}visited_hc vis[MAX_VERTEX_NUM];void dfsal_hc(algraph_hc*a,arcnode_hc*b,int k){vis[k]=TRUE;printf("%c",a->vertices[k].data);while(b){k=b->adjvex;if(!vis[k]){b=a->vertices[k].firstarc;dfsal_hc(a,b,k);} else b=b->nextarc;}}void dfstraverseal_hc(algraph_hc*a){char f;int i=0,k;for(i=0;i<a->vexnum;i++)vis[i]=FALSE;printf("遍历开始顶点:");flushall();scanf("%c",&f);k=locatevexal_hc(a,f);printf("深度遍历结果:");for(i=k;i<a->vexnum;i++)if(!vis[k])dfsal_hc(a,a->vertices[i].firstarc,i);for(i=0;i<k;i++)if(!vis[k])dfsal_hc(a,a->vertices[i].firstarc,i);}void main(){algraph_hc*a;mgraph_hc*g;char c;printf("邻接矩阵(M)\n");printf("邻接表(A)\n");printf("请选择:");c=getchar();while(c!='E'){if(c=='M'){g=createudg_hc();dfstraverse_hc(g);}else if(c=='A'){a=createaludg_hc();dfstraverseal_hc(a);} printf("\n请选择:");flushall();c=getchar();}printf("作者:黄晨");}AC D E H V1V2V4 V3V5 G2。