图的深度优先搜索,广度优先搜索,代码

一、实验目的1．掌握图的各种存储结构，特别要熟练掌握邻接矩阵和邻接表存储结构；2．遍历是图各种应用的算法的基础，要熟练掌握图的深度优先遍历和宽度优先遍历算法，复习栈和队列的应用；3．掌握图的各种应用的算法：图的连通性、连通分量和最小生成树、拓扑排序、关键路径。

二、实验内容实验内容1**图的遍历[问题描述]许多涉及图上操作的算法都是以图的遍历为基础的。

写一个程序，演示在连通无向图上遍历全部顶点。

[基本要求]建立图的邻接表的存储结构，实现无向图的深度优先遍历和广度优先遍历。

以用户指定的顶点为起点，分别输出每种遍历下的顶点访问序列。

[实现提示]设图的顶点不超过30个，每个顶点用一个编号表示（如果一个图有N个顶点，则它们的编号分别为1，2，…，N）。

通过输入图的全部边输入一个图，每条边是两个顶点编号对，可以对边依附顶点编号的输入顺序作出限制（例如从小到大）。

[编程思路]首先图的创建，采用邻接表建立，逆向插入到单链表中，特别注意无向是对称插入结点，且要把输入的字符在顶点数组中定位（LocateVex(Graph G,char *name)，以便后来的遍历操作，深度遍历算法采用递归调用，其中最主要的是NextAdjVex(Graph G, int v, int w)；FirstAdjVex （）函数的书写，依次递归下去，广度遍历用队列的辅助。

[程序代码]头文件：#include<stdio.h>#include<stdlib.h>#define MAX_VERTEX_NUM 30#define MAX_QUEUE_NUMBER 30#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;typedef int InfoType;typedef int Status;/* 定义弧的结构*/typedef struct ArcNode{int adjvex; /*该边所指向的顶点的位置*/ struct ArcNode *nextarc; /*指向下一条边的指针*/ InfoType info; /*该弧相关信息的指针*/}ArcNode;/*定义顶点的结构*/typedef struct VNode{char data[40]; /*顶点信息*/ArcNode *firstarc; /*指向第一条依附该顶点的弧的指针*/}VNode,AdjList[MAX_VERTEX_NUM];/*定义图的结构*/typedef struct {AdjList vertices;int vexnum,arcnum; /*图的当前顶点数和弧数*/int kind; /*图的类型标志*/}Graph;/*定义队列的结构*/typedef struct{int *elem;int front, rear;}Queue;/*功能选择*/void MenuSelect(int w);/*顶点定位*/int LocateVex(Graph G,char *name);/*创建无向图*/void CreateGraph(Graph &G);/*求第一个顶点*/int FirstAdjVex(Graph G, int v);/*求下一个顶点*/int NextAdjVex(Graph G, int v, int w);/*深度递归*/void DFS(Graph G, int v) ;/*深度遍历*/void DFSTravel(Graph G,int v);/*广度遍历*/void BFSTraverse(Graph G,char *name);/*初始化队列*/Status InitQueue(Queue &Q);/*判空*/Status EmptyQueue(Queue Q);/*进队*/Status EnQueue(Queue &Q, int e);/*出队*/Status DeQueue(Queue &Q, int &e);实现文件：#include <stdio.h>#include"malloc.h"#include "tuhead.h"#include "stdlib.h"#include "string.h"bool visited[MAX_VERTEX_NUM];/************************************************************ 顶点定位************************************************************/int LocateVex(Graph G,char *name){int i;for(i=1;i<=G.vexnum;i++) //从1号位置开始存储if(strcmp(name,G.vertices[i].data)==0) //相等则找到，返回位序return i;return -1;}/************************************************************ 创建无向图************************************************************/void CreateGraph(Graph &G){ArcNode *p;char name1[10],name2[10];int i,j,k;printf(" 请输入顶点数,按回车键结束：");scanf("%d",&G.vexnum);printf(" 请输入弧数,按回车键结束：");scanf("%d",&G.arcnum);printf(" 请依次输入顶点名（用空格分开且字符小于10）,按回车键结束：\n");printf(" ");for(i=1;i<=G.vexnum;i++) //从1号位置开始存储{scanf("%s",G.vertices[i].data); //从一号位置开始初始化G.vertices[i].firstarc=NULL;}printf("\n\n\n\n");printf(" ………………………………………输入小提示………………………………………\n");printf(" &&&&1 为避免输入遗漏，最好从选择任意一点，输入所有相邻边\n");printf(" &&&&2 输入边时格式(用空格分开，即格式为顶点（空格）顶点（空格)）\n");printf(" ………………………………………输入小提示………………………………………\n\n\n\n");for(k=0;k<G.arcnum;k++){printf("请输入相邻的两个顶点,按回车键结束：");scanf("%s%s",name1,name2);i=LocateVex(G,name1); //返回位序j=LocateVex(G,name2);p=(ArcNode *)malloc(sizeof(ArcNode)); //申请边节点p->adjvex=j; //插入到邻接表中，注意此处为逆向插入到单链表中p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;//无向图，注意是对称插入结点p=(ArcNode *)malloc(sizeof(ArcNode));p->adjvex=i;p->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p;}}/************************************************************ 求第一个顶点************************************************************/int FirstAdjVex(Graph G, int v){ArcNode *p;if(v>=1 && v<=G.vexnum){p=G.vertices[v].firstarc;if(p->nextarc==NULL)return 0;elsereturn (p->nextarc->adjvex); //返回第一个顶点字符}return -1;}/************************************************************ 求下一个顶点************************************************************/int NextAdjVex(Graph G, int v, int w){ //在图G中寻找第v个顶点的相对于w的下一个邻接顶点ArcNode *p;if(v>=1 && v<=G.vexnum && w>=1 && w<=G.vexnum){p=G.vertices[v].firstarc;while(p->adjvex!=w)p=p->nextarc; //在顶点v的弧链中找到顶点wif(p->nextarc!=NULL)return 0; //若已是最后一个顶点，返回0 elsereturn(p->nextarc->adjvex); //返回下一个邻接顶点的序号}return -1;}/************************************************************ 深度递归************************************************************/void DFS(Graph G, int v){int w;ArcNode *p;visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点p=G.vertices[v].firstarc; //p为依附顶点的第一条边while (p!=NULL){w=p->adjvex;if(visited[w]==0)DFS(G,w);p=p->nextarc; //下移指针}}/************************************************************ 深度遍历************************************************************/void DFSTravel(Graph G,int v){for(int i=1;i<=G.vexnum;i++)visited[i]=0;int w;ArcNode *p;visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点p=G.vertices[v].firstarc;while (p!=NULL){w=p->adjvex;if(visited[w]==0)DFS(G,w);p=p->nextarc;}}/************************************************************ 初始化队列************************************************************/Status InitQueue(Queue &Q){Q.elem = new int[MAX_QUEUE_NUMBER];Q.front = Q.rear = 0;return OK；}Status EmptyQueue(Queue Q){if(Q.front==Q.rear)return 0;elsereturn 1;}/*********************************************************** * 进队列* ***********************************************************/ Status EnQueue(Queue &Q, int e){if((Q.rear + 1)%MAX_QUEUE_NUMBER != Q.front)Q.elem[Q.rear ] = e;else ;Q.rear = (Q.rear + 1)%MAX_QUEUE_NUMBER;return OK；}/*********************************************************** * 出队列* ***********************************************************/ Status DeQueue(Queue &Q, int &e){if(Q.rear != Q.front)e = Q.elem[Q.front];else ;Q.front = (Q.front+1)%MAX_QUEUE_NUMBER;return OK；}/*********************************************************** * 广度遍历************************************************************/void BFSTraverse(Graph G,char *name){ArcNode *p;int v,w,u,k=0;Queue Q;int visited[20];for(v=1;v<=G.vexnum;v++) //初始化visited[v]=0;InitQueue(Q);for(v=LocateVex(G,name);k!=2;v=(v+1)%(G.vexnum-1)) //v为输入的字符转化的位序{if(v+1==LocateVex(G,name)) //从v开始走完图的所有顶点k++;if(visited[v]==0){visited[v]=1;printf("%s ",G.vertices[v].data); //访问第v个顶点EnQueue(Q,v); // 进队while(EmptyQueue(Q)!=0){DeQueue(Q,u); //出队p=G.vertices[u].firstarc;while(p!=NULL){w=p->adjvex; //p边的下一个顶点if(visited[w]==0){printf("%s ",G.vertices[w].data);visited[w]=1;EnQueue(Q,w);}p=p->nextarc; //下移指针}}}}}主文件：#include <stdio.h>#include"malloc.h"#include "tuhead.h"#include "stdlib.h"#include "string.h"/************************************************************ 界面控制************************************************************/void main(){printf("\n################################# 图的遍历#################################\n");printf("\n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n");printf("\n");printf(" 1 ------- 图的创建\n");printf(" 2 ------- 图的深度优先遍历\n");printf(" 3 ------- 图的广度优先遍历\n");printf(" 0 ------- 退出\n");printf("\n $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n");printf("\n");printf("请输入选择的操作代码（0-3）按回车键结束\n");MenuSelect(1);}/************************************************************ 功能选择************************************************************/void MenuSelect(int w){int select,done;int v;Graph G; char name[10];while (done) {printf("input the operating code : ");scanf("%d",&select);switch(select){case 1: printf("根据要求创建图:\n ");CreateGraph(G);break;case 2: printf("请输入深度优先遍历开始点的名：");scanf("%s",name);v=LocateVex(G,name); //将输入字符找到在顶点数组name对应的序号Vprintf("深度优先遍历：");DFSTravel(G,v);printf("\n");break;case 3: printf("请输入广度优先遍历开始点的名：");scanf("%s",name);printf("广度优先遍历：");BFSTraverse(G,name);printf("\n");break;case 0: done=0; break;default: printf(" ERROR\n");}printf("\n");}}[实验数据与结果]测试数据：实验结果。

深度优先搜索示例代码深度优先搜索（Depth First Search，DFS）是一种用于遍历或搜索树或图的算法。

它通过从根节点或某个指定节点开始，尽可能深地探索每个分支，直到找到目标节点或到达叶子节点为止。

本文将给出一个深度优先搜索的示例代码，帮助读者理解算法的实现过程。

示例代码如下：```class Graph:def __init__(self):self.graph = {}def add_edge(self, vertex, edge):if vertex in self.graph:self.graph[vertex].append(edge)else:self.graph[vertex] = [edge]def dfs(self, start):visited = set()self.dfs_helper(start, visited)def dfs_helper(self, vertex, visited):visited.add(vertex)print(vertex)if vertex in self.graph:for neighbor in self.graph[vertex]:if neighbor not in visited:self.dfs_helper(neighbor, visited)```在示例代码中，首先定义了一个`Graph`类，用于表示图结构。

`Graph`类包含了两个方法：`add_edge`用于添加边，`dfs`用于执行深度优先搜索。

`add_edge`方法用于向图中添加边，其中`vertex`表示起始节点，`edge`表示目标节点。

`dfs`方法用于执行深度优先搜索，其中`start`表示搜索的起始节点。

在深度优先搜索的实现中，我们使用了一个`visited`集合来记录已经访问过的节点，避免重复访问。

`dfs_helper`方法用于递归地进行深度优先搜索，其中`vertex`表示当前访问的节点，`visited`表示已访问节点的集合。

dfs和bfs算法代码深度优先搜索（DFS）和广度优先搜索（BFS）是常用的图遍历算法，它们可以帮助我们解决很多实际问题。

本文将详细介绍这两种算法的实现原理和应用场景。

一、深度优先搜索（DFS）深度优先搜索是一种递归的搜索算法，它从图的某个顶点开始，沿着一条路径尽可能深地搜索，直到无法继续为止，然后回溯到上一级节点，继续搜索其他路径。

DFS一般使用栈来实现。

DFS的代码实现如下：```def dfs(graph, start):visited = set() # 用一个集合来记录已访问的节点stack = [start] # 使用栈来实现DFSwhile stack:node = stack.pop() # 取出栈顶元素if node not in visited:visited.add(node) # 将节点标记为已访问neighbors = graph[node] # 获取当前节点的邻居节点stack.extend(neighbors) # 将邻居节点入栈return visited```DFS的应用场景很多，比如迷宫问题、拓扑排序、连通分量的计算等。

在迷宫问题中，我们可以使用DFS来寻找从起点到终点的路径；在拓扑排序中，DFS可以用来确定任务的执行顺序；在连通分量的计算中，DFS可以用来判断图是否连通，并将图分割成不同的连通分量。

二、广度优先搜索（BFS）广度优先搜索是一种逐层遍历的搜索算法，它从图的某个顶点开始，先访问该顶点的所有邻居节点，然后再访问邻居节点的邻居节点，依次进行，直到遍历完所有节点。

BFS一般使用队列来实现。

BFS的代码实现如下：```from collections import dequedef bfs(graph, start):visited = set() # 用一个集合来记录已访问的节点queue = deque([start]) # 使用队列来实现BFSwhile queue:node = queue.popleft() # 取出队首元素if node not in visited:visited.add(node) # 将节点标记为已访问neighbors = graph[node] # 获取当前节点的邻居节点queue.extend(neighbors) # 将邻居节点入队return visited```BFS的应用场景也很广泛，比如寻找最短路径、社交网络中的人际关系分析等。

2024年6月GESP编程能力认证C++等级考试七级真题(含答案)一、单选题（每题2分，共30分）。

1. 下列C++代码的输出结果是（）。

2. 对于如下图的二叉树，说法正确的是（）。

A. 先序遍历是132。

B. 中序遍历是123。

C. 后序遍历是312。

D. 先序遍历和后序遍历正好是相反的。

3. 已知两个序列s1={1,3,4,5,6,7,7,8,1}、s2={3,5,7,4,8,2,9,5,1}，则它们的最长公共子序列是（）。

4. 关于序列{2,7,1,5,6,4,3,8,9}，以下说法错误的是（）。

A. {2,5,6,8,9}是它的最长上升子序列。

B. {1,5,6,8,9}是它的最长上升子序列。

C. {7,5,4,3}是它的最长下降子序列。

D. {1,5,6,8,9}是它的唯一最长上升子序列。

5. 关于图的深度优先搜索和广度优先搜索，下列说法错误的是（）。

A. 二叉树是也是一种图。

B. 二叉树的前序遍历和后序遍历都是深度优先搜索的一种。

C. 深度优先搜索可以从任意根节点开始。

D. 二叉树的后序遍历也是广度优先搜索的一种。

6. 对于如下二叉树，下面访问顺序说法错误的是（）。

A. HDEBFIGCA不是它的后序遍历序列B. ABCDEFGHI是它的广度优先遍历序列C. ABDHECFGI是它的深度优先遍历序列D. ABDHECFGI是它的先序遍历序列7. 以下哪个方案不能合理解决或缓解哈希表冲突（）。

A. 丢弃发生冲突的新元素。

B. 在每个哈希表项处，使用不同的哈希函数再建立一个哈希表，管理该表项的冲突元素。

C. 在每个哈希表项处，建立二叉排序树，管理该表项的冲突元素。

D. 使用不同的哈希函数建立额外的哈希表，用来管理所有发生冲突的元素。

8. 在C++中，关于运算符&，下面说法正确的是（）。

9. 下面关于图的说法正确的是（）。

A. 在无向图中，环是指至少包含三个不同顶点，并且第一个顶点和最后一个顶点是相同的路径。

深度优先搜索和⼴度优先搜索 深度优先搜索和⼴度优先搜索都是图的遍历算法。

⼀、深度优先搜索（Depth First Search） 1、介绍 深度优先搜索（DFS），顾名思义，在进⾏遍历或者说搜索的时候，选择⼀个没有被搜过的结点（⼀般选择顶点），按照深度优先，⼀直往该结点的后续路径结点进⾏访问，直到该路径的最后⼀个结点，然后再从未被访问的邻结点进⾏深度优先搜索，重复以上过程，直⾄所有点都被访问，遍历结束。

⼀般步骤：（1）访问顶点v；（2）依次从v的未被访问的邻接点出发，对图进⾏深度优先遍历；直⾄图中和v有路径相通的顶点都被访问；（3）若此时图中尚有顶点未被访问，则从⼀个未被访问的顶点出发，重新进⾏深度优先遍历，直到图中所有顶点均被访问过为⽌。

可以看出，深度优先算法使⽤递归即可实现。

2、⽆向图的深度优先搜索 下⾯以⽆向图为例，进⾏深度优先搜索遍历： 遍历过程： 所以遍历结果是：A→C→B→D→F→G→E。

3、有向图的深度优先搜索 下⾯以有向图为例，进⾏深度优先遍历： 遍历过程： 所以遍历结果为：A→B→C→E→D→F→G。

⼆、⼴度优先搜索（Breadth First Search） 1、介绍 ⼴度优先搜索（BFS）是图的另⼀种遍历⽅式，与DFS相对，是以⼴度优先进⾏搜索。

简⾔之就是先访问图的顶点，然后⼴度优先访问其邻接点，然后再依次进⾏被访问点的邻接点，⼀层⼀层访问，直⾄访问完所有点，遍历结束。

2、⽆向图的⼴度优先搜索 下⾯是⽆向图的⼴度优先搜索过程： 所以遍历结果为：A→C→D→F→B→G→E。

3、有向图的⼴度优先搜索 下⾯是有向图的⼴度优先搜索过程： 所以遍历结果为：A→B→C→E→F→D→G。

三、两者实现⽅式对⽐ 深度优先搜索⽤栈（stack）来实现，整个过程可以想象成⼀个倒⽴的树形：把根节点压⼊栈中。

每次从栈中弹出⼀个元素，搜索所有在它下⼀级的元素，把这些元素压⼊栈中。

并把这个元素记为它下⼀级元素的前驱。

广度优先和深度优先的例子广度优先搜索(BFS)和深度优先搜索(DFS)是图遍历中常用的两种算法。

它们在解决许多问题时都能提供有效的解决方案。

本文将分别介绍广度优先搜索和深度优先搜索，并给出各自的应用例子。

一、广度优先搜索(BFS)广度优先搜索是一种遍历或搜索图的算法，它从起始节点开始，逐层扩展，先访问起始节点的所有邻居节点，再依次访问其邻居节点的邻居节点，直到遍历完所有节点或找到目标节点。

例子1：迷宫问题假设有一个迷宫，迷宫中有多个房间，每个房间有四个相邻的房间：上、下、左、右。

现在我们需要找到从起始房间到目标房间的最短路径。

可以使用广度优先搜索算法来解决这个问题。

例子2：社交网络中的好友推荐在社交网络中，我们希望给用户推荐可能认识的新朋友。

可以使用广度优先搜索算法从用户的好友列表开始，逐层扩展，找到可能认识的新朋友。

例子3：网页爬虫网页爬虫是搜索引擎抓取网页的重要工具。

爬虫可以使用广度优先搜索算法从一个网页开始，逐层扩展，找到所有相关的网页并进行抓取。

例子4：图的最短路径在图中，我们希望找到两个节点之间的最短路径。

可以使用广度优先搜索算法从起始节点开始，逐层扩展，直到找到目标节点。

例子5：推荐系统在推荐系统中，我们希望给用户推荐可能感兴趣的物品。

可以使用广度优先搜索算法从用户喜欢的物品开始，逐层扩展，找到可能感兴趣的其他物品。

二、深度优先搜索(DFS)深度优先搜索是一种遍历或搜索图的算法，它从起始节点开始，沿着一条路径一直走到底，直到不能再继续下去为止，然后回溯到上一个节点，继续探索其他路径。

例子1：二叉树的遍历在二叉树中，深度优先搜索算法可以用来实现前序遍历、中序遍历和后序遍历。

通过深度优先搜索算法，我们可以按照不同的遍历顺序找到二叉树中所有节点。

例子2：回溯算法回溯算法是一种通过深度优先搜索的方式，在问题的解空间中搜索所有可能的解的算法。

回溯算法常用于解决组合问题、排列问题和子集问题。

例子3：拓扑排序拓扑排序是一种对有向无环图(DAG)进行排序的算法。

哈尔滨工业大学计算机科学与技术学院实验报告课程名称：数据结构与算法课程类型：必修实验项目名称：图的搜索与应用实验题目：图的深度和广度搜索与拓扑排序设计成绩报告成绩指导老师一、实验目的1.掌握图的邻接表的存储形式。

2.熟练掌握图的搜索策略，包括深度优先搜索与广度优先搜索算法。

3.掌握有向图的拓扑排序的方法。

二、实验要求及实验环境实验要求：1.以邻接表的形式存储图。

2.给出图的深度优先搜索算法与广度优先搜索算法。

3.应用搜索算法求出有向图的拓扑排序。

实验环境：寝室+机房+编程软件（NetBeans IDE 6.9.1）。

三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）数据类型定义：template <class T>class Node {//定义边public:int adjvex;//定义顶点所对应的序号Node *next;//指向下一顶点的指针int weight;//边的权重};template <class T>class Vnode {public:T vertex;Node<T> *firstedge;};template <class T>class Algraph {public:Vnode<T> adjlist[Max];int n;int e;int mark[Max];int Indegree[Max];};template<class T>class Function {public://创建有向图邻接表void CreatNalgraph(Algraph<T>*G);//创建无向图邻接表void CreatAlgraph(Algraph<T> *G);//深度优先递归搜索void DFSM(Algraph<T>*G, int i);void DFS(Algraph<T>* G);//广度优先搜索void BFS(Algraph<T>* G);void BFSM(Algraph<T>* G, int i);//有向图的拓扑排序void Topsort(Algraph<T>*G);/得到某个顶点内容所对应的数组序号int Judge(Algraph<T>* G, T name); };主程序流程图：程序开始调用关系：主函数调用五个函数 CreatNalgraph(G)//创建有向图 DFS(G) //深度优先搜索 BFS(G) //广度优先搜索 Topsort(G) //有向图拓扑排序 CreatAlgraph(G) //创建无向图其中 CreatNalgraph(G) 调用Judge(Algraph<T>* G, T name)函数；DFS(G)调用DFSM(Algraph<T>* G , int i)函数；BFS(G) 调用BFSM(Algraph<T>* G, int k)函数；CreatAlgraph(G) 调选择图的类型无向图有向图深 度 优 先 搜 索广度优先搜索 深 度 优 先 搜 索 广度优先搜索拓 扑 排 序程序结束用Judge(Algraph<T>* G, T name)函数。

数据结构课设——有向图的深度、⼴度优先遍历及拓扑排序任务：给定⼀个有向图，实现图的深度优先, ⼴度优先遍历算法，拓扑有序序列，并输出相关结果。

功能要求：输⼊图的基本信息，并建⽴图存储结构（有相应提⽰），输出遍历序列，然后进⾏拓扑排序，并测试该图是否为有向⽆环图，并输出拓扑序列。

按照惯例，先上代码，注释超详细：#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 。

深度优先搜索算法详解及代码实现深度优先搜索（Depth-First Search，DFS）是一种常见的图遍历算法，用于遍历或搜索图或树的所有节点。

它的核心思想是从起始节点开始，沿着一条路径尽可能深入地访问其他节点，直到无法继续深入为止，然后回退到上一个节点，继续搜索未访问过的节点，直到所有节点都被访问为止。

一、算法原理深度优先搜索算法是通过递归或使用栈（Stack）的数据结构来实现的。

下面是深度优先搜索算法的详细步骤：1. 选择起始节点，并标记该节点为已访问。

2. 从起始节点出发，依次访问与当前节点相邻且未被访问的节点。

3. 若当前节点有未被访问的邻居节点，则选择其中一个节点，将其标记为已访问，并将当前节点入栈。

4. 重复步骤2和3，直到当前节点没有未被访问的邻居节点。

5. 若当前节点没有未被访问的邻居节点，则从栈中弹出一个节点作为当前节点。

6. 重复步骤2至5，直到栈为空。

深度优先搜索算法会不断地深入到图或树的某一分支直到底部，然后再回退到上层节点继续搜索其他分支。

因此，它的搜索路径类似于一条深入的迷宫路径，直到没有其他路径可走后，再原路返回。

二、代码实现以下是使用递归方式实现深度优先搜索算法的代码：```pythondef dfs(graph, start, visited):visited.add(start)print(start, end=" ")for neighbor in graph[start]:if neighbor not in visited:dfs(graph, neighbor, visited)# 示例数据graph = {'A': ['B', 'C'],'B': ['A', 'D', 'E'],'C': ['A', 'F'],'D': ['B'],'E': ['B', 'F'],'F': ['C', 'E']}start_node = 'A'visited = set()dfs(graph, start_node, visited)```上述代码首先定义了一个用于实现深度优先搜索的辅助函数`dfs`。