图的深度优先遍历

最新推荐文章于 2023-10-23 22:12:03 发布
最新推荐文章于 2023-10-23 22:12:03 发布
阅读量545 收藏
点赞数
分类专栏： leetcode算法

深度优先遍历是连通图的一种遍历策略。其基本思想如下：

设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x，y)。若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。上述过程直至从x出发的所有边都已检测过为止。

例如下图中：

1.从0开始，首先找到0的关联顶点3
2.由3出发，找到1；由1出发，没有关联的顶点。
3.回到3，从3出发，找到2；由2出发，没有关联的顶点。
4.回到4，出4出发，找到1，因为1已经被访问过了，所以不访问。
所以最后顺序是0,3,1,2,4
c语言实现如下：（使用邻接矩阵存储）

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #define VERTEXNUM 5  
  4.   
  5. void createGraph(int (*edge)[VERTEXNUM], int start, int end);  
  6. void displayGraph(int (*edge)[VERTEXNUM]);  
  7. void DFT(int (*edge)[VERTEXNUM],int* vertexStatusArr);  
  8. void DFTcore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr);  
  9.   
  10. int main(void){  
  11.         //动态创建存放边的二维数组  
  12.         int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);  
  13.         int i,j;  
  14.         for(i=0;i<VERTEXNUM;i++){  
  15.                 for(j=0;j<VERTEXNUM;j++){  
  16.                         edge[i][j] = 0;  
  17.                 }  
  18.         }  
  19.         //存放顶点的遍历状态，0：未遍历，1：已遍历    
  20.         int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
  21.         for(i=0;i<VERTEXNUM;i++){  
  22.                 vertexStatusArr[i] = 0;  
  23.         }  
  24.           
  25.         printf("after init:\n");  
  26.         displayGraph(edge);  
  27.         //创建图  
  28.         createGraph(edge,0,3);  
  29.         createGraph(edge,0,4);  
  30.         createGraph(edge,3,1);  
  31.         createGraph(edge,3,2);  
  32.         createGraph(edge,4,1);  
  33.   
  34.         printf("after create:\n");  
  35.         displayGraph(edge);  
  36.         //深度优先遍历  
  37.         DFT(edge,vertexStatusArr);  
  38.   
  39.         free(edge);  
  40.         return 0;  
  41. }  
  42. //创建图   
  43. void createGraph(int (*edge)[VERTEXNUM], int start, int end){  
  44.         edge[start][end] = 1;  
  45. }  
  46. //打印存储的图  
  47. void displayGraph(int (*edge)[VERTEXNUM]){  
  48.         int i,j;  
  49.         for(i=0;i<VERTEXNUM;i++){  
  50.                 for(j=0;j<VERTEXNUM;j++){  
  51.                         printf("%d ",edge[i][j]);  
  52.                 }  
  53.                 printf("\n");  
  54.         }  
  55. }  
  56. //深度优先遍历  
  57. void DFT(int (*edge)[VERTEXNUM], int* vertexStatusArr){  
  58.         printf("start BFT graph:\n");  
  59.         int i;  
  60.         for(i=0;i<VERTEXNUM;i++){  
  61.                 DFTcore(edge,i,vertexStatusArr);  
  62.         }  
  63.         printf("\n");  
  64. }  
  65. void DFTcore(int (*edge)[VERTEXNUM],int i,int* vertexStatusArr){  
  66.         if(vertexStatusArr[i] == 1){  
  67.                 return;  
  68.         }  
  69.         printf("%d ",i);  
  70.         vertexStatusArr[i] = 1;  
  71.   
  72.         int j;  
  73.         for(j=0;j<VERTEXNUM;j++){  
  74.                 if(edge[i][j] == 1){  
  75.                         DFTcore(edge, j, vertexStatusArr);  
  76.                 }  
  77.         }  
  78. }  


c语言实现如下：（使用邻接表存储）

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3. #define VERTEXNUM 5  
  4. //存放顶点的邻接表元素    
  5. typedef struct edge{  
  6.         int vertex;  
  7.         struct edge* next;  
  8. }st_edge;  
  9.   
  10. void createGraph(st_edge** edge, int start, int end);  
  11. void displayGraph(st_edge** edge);  
  12. void delGraph(st_edge** edge);  
  13. void DFT(st_edge** edge,int* vertexStatusArr);  
  14. void DFTcore(st_edge** edge,int i,int* vertexStatusArr);  
  15.   
  16. int main(void){  
  17.         //动态创建存放边的指针数组     
  18.         st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);  
  19.         int i;  
  20.         for(i=0;i<VERTEXNUM;i++){  
  21.                 edge[i] = NULL;  
  22.         }  
  23.         //存放顶点的遍历状态，0：未遍历，1：已遍历    
  24.         int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);  
  25.         for(i=0;i<VERTEXNUM;i++){  
  26.                 vertexStatusArr[i] = 0;  
  27.         }  
  28.   
  29.         printf("after init:\n");  
  30.         displayGraph(edge);  
  31.         //创建图    
  32.         createGraph(edge,0,3);  
  33.         createGraph(edge,0,4);  
  34.         createGraph(edge,3,1);  
  35.         createGraph(edge,3,2);  
  36.         createGraph(edge,4,1);  
  37.   
  38.         printf("after create:\n");  
  39.         displayGraph(edge);  
  40.         //深度优先遍历   
  41.         DFT(edge,vertexStatusArr);  
  42.         //释放邻接表占用的内存    
  43.         delGraph(edge);  
  44.         edge = NULL;  
  45.         free(vertexStatusArr);  
  46.         vertexStatusArr = NULL;  
  47.         return 0;  
  48. }  
  49. //创建图   
  50. void createGraph(st_edge** edge, int start, int end){  
  51.         st_edge* newedge = (st_edge*)malloc(sizeof(st_edge));  
  52.         newedge->vertex = end;  
  53.         newedge->next = NULL;  
  54.         edge = edge + start;  
  55.         while(*edge != NULL){  
  56.                 edge = &((*edge)->next);  
  57.         }  
  58.         *edge = newedge;  
  59. }  
  60. //打印存储的图   
  61. void displayGraph(st_edge** edge){  
  62.         int i;  
  63.         st_edge* p;  
  64.         for(i=0;i<VERTEXNUM;i++){  
  65.                 printf("%d:",i);  
  66.                 p = *(edge+i);  
  67.                 while(p != NULL){  
  68.                         printf("%d ",p->vertex);  
  69.                         p = p->next;  
  70.                 }  
  71.                 printf("\n");  
  72.         }  
  73. }  
  74. //释放邻接表占用的内存   
  75. void delGraph(st_edge** edge){  
  76.         int i;  
  77.         st_edge* p;  
  78.         st_edge* del;  
  79.         for(i=0;i<VERTEXNUM;i++){  
  80.                 p = *(edge+i);  
  81.                 while(p != NULL){  
  82.                         del = p;  
  83.                         p = p->next;  
  84.                         free(del);  
  85.                 }  
  86.                 edge[i] = NULL;  
  87.         }  
  88.         free(edge);  
  89. }  
  90. //深度优先遍历   
  91. void DFT(st_edge** edge,int* vertexStatusArr){  
  92.         printf("start BFT graph:\n");  
  93.         int i;  
  94.         for(i=0;i<VERTEXNUM;i++){  
  95.                 DFTcore(edge,i,vertexStatusArr);  
  96.         }  
  97.         printf("\n");  
  98. }  
  99.   
  100. void DFTcore(st_edge** edge,int i,int* vertexStatusArr){  
  101.         if(vertexStatusArr[i] == 1){  
  102.                 return;  
  103.         }  
  104.         printf("%d ",i);  
  105.         vertexStatusArr[i] = 1;  
  106.         st_edge* p = *(edge+i);  
  107.         while(p != NULL){  
  108.                 DFTcore(edge, p->vertex, vertexStatusArr);  
  109.                 p = p->next;  
  110.         }  
  111. }  
报恩的猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（有向）图的深度优先遍历算法模板算法(java源码)
01-21
/* * （有向）图的深度优先遍历算法模板 */ package dsa; public abstract class DFS extends GraphTraverse { //变量 protected static int clock = 0;//遍历过程中使用的计时钟 //构造方法 public DFS(Graph g) { super(g); } //深度优先遍历算法 protected Object traverse(Vertex v, Object info) {//从顶点v出发，做深度优先查找 if (UNDISCOVERED != v.getStatus()) return null;//跳过已访问过的顶点（针对非连通图） v.setDStamp(clock++); v.setStatus(DISCOVERED); visit(v, info);//访问当前顶点 for (Iterator it = v.outEdges(); it.hasNext();) {//检查与顶点v Edge e = (Edge)it.getNext();//通过边e = (v, u) Vertex u = (Vertex)e.getVPosInV(1).getElem();//相联的每一顶点u switch (u.getStatus()) {//根据u当前的不同状态，分别做相应处理 case UNDISCOVERED ://若u尚未被发现，则 e.setType(TREE);//e被归类为“树边” traverse(u, info);//从u出发，继续做深度优先查找 break; case DISCOVERED ://若u已经被发现，但对其访问尚未结束，则 e.setType(BACKWARD);//将e归类为“后向跨边” break; default ://VISITED，即对u的访问已经结束 if (u.getDStamp() < v.getDStamp())//若相对于v，u被发现得更早，则 e.setType(CROSS);//将e归类为“横跨边” else//否则 e.setType(FORWARD);//将e归类为“前向跨边” break; } }//至此，v的所有邻居都已访问结束，故 v.setFStamp(clock++); v.setStatus(VISITED);//将v标记为VISITED return null;//然后回溯 } }
1047-图的深度优先遍历序列
weixin_30713953的博客
11-21 675
描述 图(graph)是数据结构 G=(V,E)，其中V是G中结点的有限非空集合,结点的偶对称为边(edge)；E是G中边的有限集合。设V={0,1,2,……,n-1}，图中的结点又称为顶点(vertex)，有向图(directed graph)指图中代表边的偶对是有序的，用<u，v>代表一条有向边（又称为弧），则u称为该边的始点（尾），v称为边的终点（头）。无向图(undir...
有向图的深度优先遍历
weixin_53067415的博客
10-06 3204
【代码】有向图的深度优先遍历。
【算法导论】有向图的深度优先搜索遍历
热门推荐
青峰碧陋室
12-15 2万+
在前面的文章中，我已经讨论了无向图的遍历，现在发现在有向图中，可能会发生无法遍历到所有节点的情况。因此在经历一次深度优先搜索遍历后，如果还存在未被搜索到的节点，则需要再从新的节点开始进行深度优先搜索遍历，直到访问完所有节点。 以下面的有向图为例： 如果从a开始进行深度优先搜索遍历，则会得到  a b c d h g f 后结束，因此我们还要 从未访问到的节点e进行第二次深度优先搜索遍历
记数据结构之有向图的深度优先遍历，广度优先遍历
GG_Killer的博客
11-26 9223
深度优先遍历(Depth-First Traversal) 假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有
无向图建立、深度优先遍历和广度优先遍历实现算法[借鉴].pdf
10-14
无向图建立、深度优先遍历和广度优先遍历实现算法 本文将详细介绍无向图的建立、深度优先遍历和广度优先遍历的实现算法。这些算法是数据结构中非常重要的内容，掌握它们对后续学习和应用非常重要。 一、无向图的...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
JavaScript中的深度优先遍历(DFS)和广度优先遍历(BFS)
01-08
在JavaScript中，深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search）是两种常见的图或树的遍历算法，广泛应用于数据结构和算法中，例如在游戏编程、图论问题解决、网页爬虫等领域...
深度优先算法（DFS）遍历有向无环图寻找最优路径
11-27
采用深度优先算法（DFS）遍历有向无环图寻找最优路径，经过优化的深度优先算法，在遍历有向无环图的时候保存路径，并计算路径权值，最总返回最优路径及最有路径的权值
图的深度优先遍历 动画
04-01
关于C语言的算法时候可能用到的图的深度优先遍历算法动画详解
图的深度优先和广度优先搜索动态演示图3张
05-14
广度优先搜索和宽度优先搜索的动画演示，均为gif图，大家可以自行看看，理解思路或者放Ppt里很好用，怎么分数是5分，编辑不了了？ 请管理员修改为1分，谢谢
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历.doc
10-10
"建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历" 本文档主要介绍了图的存储方式，包括邻接矩阵和邻接表两种存储方法，并在此基础上实现了图的深度优先遍历和广度优先遍历。 一、图...
图的深度优先遍历（Depth First Search）
cao818的博客
09-14 8165
图的深度优先遍历（Depth First Search） 基本思想 类似于二叉树的先序遍历 假设图中所有结点均未被访问，从初始结点访问，访问其第一个邻接结点，接着以被访问的邻接结点作为初始结点，访问它的第一个邻接结点。 递归的过程。 算法步骤 访问初始结点v，并标记为已访问 查找结点v的第一个邻接结点w 若w存在，则继续执行4，若不存在则回到第1步，从v的下一个结点继续 若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123
有向图深度优先
qq_43236620的博客
11-27 3942
1）深度优先遍历（deep first traverse） 定义：假设给定图G的初态是所有顶点均未曾访问过，在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有...
自定义有向图的深度优先遍历（DFS）
少歌的博客
05-24 6667
何为图（Graph） 形似如下抽象结构： 这看起来的确有点抽象￣□￣｜｜。。 我们再看一张： 这是一张二叉树，我在之前图的基础上减去了几根“联系”就变成了树。 所以在一定程度上，可以把图理解为树延伸（图进一步的打破了树的“规矩”）。 程序中的“图” 图的存储 需要一个集合（Set）来存储我们的节点元素。 需要一个映射（HashMap）来存储节点是否被访问过。 需要一个 HashMap<T, ArrayList> 来存储节点间的通路。 如下图所示： 代码实现 DFS深度优先遍历
图(graph)的遍历----深度优先(DFS)遍历
最新发布
m0_73633088的博客
10-23 1万+
在前面学习过二叉树的时候我们就已经接触到深度优先搜索和广度优先搜索，二叉树的前序遍历和后序遍历都属于深度优先遍历的一种，但是对于二叉树这种有规律的数据结很容易理解，但是如果是对于图这种没有规律的数据结构又该如何去实现深度优先和广度优先遍历呢？下面就一起来看看吧！
图深度优先遍历和广度优先遍历
10-14
图的深度优先遍历和广度优先遍历是两种常见的图遍历算法。 深度优先遍历（Depth First Search，DFS）是一种先访问深度较深的节点的搜索方法。具体实现可以使用递归或栈来实现。在遍历过程中，每个节点只会被访问一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值