17、数据结构与算法 - 图（二）深度优先遍历

最新推荐文章于 2022-11-21 16:21:30 发布
最新推荐文章于 2022-11-21 16:21:30 发布
阅读量238 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shengdaVolleyball/article/details/106364932
版权

图的遍历

一个顶点只能访问一次，就需要用一个标记来标识当前顶点是否访问过

有两种遍历形式

  • 深度优先遍历
  • 广度优先比那里

 

深度优先遍历

将图画成如下图的形式。
右手原则，先走右边

先走A B C D E F(由于A被标记过了，所以到G) G H
这样走完之后会发现 I 并没有走，那么就再回退一次，找到没有标识的顶点

1.1 邻接矩阵深度优先遍历

思路
1、将图的定点和边信息输入到图结构中
2、创建一个visited 数组，用来表示定点是否已经被遍历过
3、初始化visited 数组，将数组中元素置为false
4、选择顶点开始遍历（注意非联通图的情况）
5、进入递归；打印i 对应的顶点信息，并将该顶点标识为已遍历。
6、循环遍历边表，判断当前arc[i][j] 是否等于1，并且当前该顶点没有被遍历过，则继递归DFS

#include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef char VertexType; /* 顶点类型应由用户定义 */
typedef int EdgeType; /* 边上的权值类型应由用户定义 */

#define MAXSIZE 9 /* 存储空间初始分配量 */
#define MAXEDGE 15
#define MAXVEX 9
#define INFINITYC 65535

typedef struct
{
    VertexType vexs[MAXVEX]; /* 顶点表 */
    EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵，可看作边表 */
    int numVertexes, numEdges; /* 图中当前的顶点数和边数 */
}MGraph;

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

构建连接矩阵

/*4.1 构建一个邻接矩阵*/
void CreateMGraph(MGraph *G)
{
    int i, j;
    
    //1. 确定图的顶点数以及边数
    G->numEdges=15;
    G->numVertexes=9;
    
    /*2.读入顶点信息，建立顶点表 */
    G->vexs[0]='A';
    G->vexs[1]='B';
    G->vexs[2]='C';
    G->vexs[3]='D';
    G->vexs[4]='E';
    G->vexs[5]='F';
    G->vexs[6]='G';
    G->vexs[7]='H';
    G->vexs[8]='I';
    
    /*3. 初始化图中的边表*/
    for (i = 0; i < G->numVertexes; i++)
    {
        for ( j = 0; j < G->numVertexes; j++)
        {
            G->arc[i][j]=0;
        }
    }
    
    /*4.将图中的连接信息输入到边表中*/
    G->arc[0][1]=1;
    G->arc[0][5]=1;
    
    G->arc[1][2]=1;
    G->arc[1][8]=1;
    G->arc[1][6]=1;
    
    G->arc[2][3]=1;
    G->arc[2][8]=1;
    
    G->arc[3][4]=1;
    G->arc[3][7]=1;
    G->arc[3][6]=1;
    G->arc[3][8]=1;
    
    G->arc[4][5]=1;
    G->arc[4][7]=1;
    
    G->arc[5][6]=1;
    
    G->arc[6][7]=1;
    
    /*5.无向图是对称矩阵.构成对称*/
    for(i = 0; i < G->numVertexes; i++)
    {
        for(j = i; j < G->numVertexes; j++)
        {
            G->arc[j][i] =G->arc[i][j];
        }
    }
}

DFS(深度优先)遍历

/*4.2 DFS遍历*/
Boolean visited[MAXVEX]; /* 访问标志的数组 */
//1. 标识顶点是否被标记过;
//2. 选择从某一个顶点开始(注意:非连通图的情况)
//3. 进入递归,打印i点信息,标识; 边表
//4. [i][j] 是否等于1,没有变遍历过visted
void DFS(MGraph G,int i){
    //1.
    visited[i] = TRUE;
    printf("%c ",G.vexs[i]);
    
    //2.0~numVertexes 遍历所有的定点
    for(int j = 0; j < G.numVertexes;j++){
//        找到与当前定点有关联的 == 1 同时没有访问过的顶点 递归
        if(G.arc[i][j] == 1 && !visited[j])
            DFS(G, j);
    }
}

void DFSTravese(MGraph G){
    //1.初始化
    for(int i=0;i<G.numVertexes;i++){
        visited[i] = FALSE;
    }
    
    //2.某一个顶点
    for(int i = 0;i<G.numVertexes;i++){
        if(!visited[i]){
            DFS(G, i);
        }
    }
}

验证

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("邻接矩阵的深度优先遍历!\n");
    MGraph G;
    CreateMGraph(&G);
    DFSTravese(G);
    printf("\n");
    return 0;
}

 结果

邻接矩阵的深度优先遍历!
A B C D E F G H I

 

1.2 邻接表对图的遍历处理

思路
1、利用邻接矩阵将信息存储到邻接表中
2、创建一个visited 数组，用来表示定点是否已经被遍历过
3、初始化visited 数组，将数组中元素置为false
4、选择顶点开始遍历（注意非联通图的情况）
5、进入递归；打印i 对应的顶点信息，并将该顶点标识为已遍历。
6、循环遍历边表，判断当前顶点是否等于1，并且当前该顶点没有被遍历过，则继递归DFS
A F G H E D I C B

#include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 9 /* 存储空间初始分配量 */
#define MAXEDGE 15
#define MAXVEX 9
#define INFINITYC 65535

typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

typedef char VertexType; /* 顶点类型应由用户定义 */
typedef int EdgeType; /* 边上的权值类型应由用户定义 */

/* 邻接矩阵结构 */
typedef struct
{
    VertexType vexs[MAXVEX]; /* 顶点表 */
    EdgeType arc[MAXVEX][MAXVEX];/* 邻接矩阵,可看作边表 */
    int numVertexes, numEdges; /* 图中当前的顶点数和边数 */
}MGraph;

/* 邻接表结构****************** */
typedef struct EdgeNode /* 边表结点 */
{
    int adjvex;    /* 邻接点域,存储该顶点对应的下标 */
    int weight;        /* 用于存储权值,对于非网图可以不需要 */
    struct EdgeNode *next; /* 链域,指向下一个邻接点 */
}EdgeNode;

typedef struct VertexNode /* 顶点表结点 */
{
    int in;    /* 顶点入度 */
    char data; /* 顶点域,存储顶点信息 */
    EdgeNode *firstedge;/* 边表头指针 */
}VertexNode, AdjList[MAXVEX];

typedef struct
{
    AdjList adjList;
    int numVertexes,numEdges; /* 图中当前顶点数和边数 */
}graphAdjList,*GraphAdjList;
/*4.1 构建一个邻接矩阵*/
void CreateMGraph(MGraph *G)
{
    int i, j;
    
    //1. 确定图的顶点数以及边数
    G->numEdges=15;
    G->numVertexes=9;
    
    /*2.读入顶点信息，建立顶点表 */
    G->vexs[0]='A';
    G->vexs[1]='B';
    G->vexs[2]='C';
    G->vexs[3]='D';
    G->vexs[4]='E';
    G->vexs[5]='F';
    G->vexs[6]='G';
    G->vexs[7]='H';
    G->vexs[8]='I';
    
    /*3. 初始化图中的边表*/
    for (i = 0; i < G->numVertexes; i++)
    {
        for ( j = 0; j < G->numVertexes; j++)
        {
            G->arc[i][j]=0;
        }
    }
    
    /*4.将图中的连接信息输入到边表中*/
    G->arc[0][1]=1;
    G->arc[0][5]=1;
    
    G->arc[1][2]=1;
    G->arc[1][8]=1;
    G->arc[1][6]=1;
    
    G->arc[2][3]=1;
    G->arc[2][8]=1;
    
    G->arc[3][4]=1;
    G->arc[3][7]=1;
    G->arc[3][6]=1;
    G->arc[3][8]=1;
    
    G->arc[4][5]=1;
    G->arc[4][7]=1;
    
    G->arc[5][6]=1;
    
    G->arc[6][7]=1;
    
    /*5.无向图是对称矩阵.构成对称*/
    for(i = 0; i < G->numVertexes; i++)
    {
        for(j = i; j < G->numVertexes; j++)
        {
            G->arc[j][i] =G->arc[i][j];
        }
    }
}
/*4.2 利用邻接矩阵构建邻接表*/
void CreateALGraph(MGraph G,GraphAdjList *GL){
    
    //1.创建邻接表,并且设计邻接表的顶点数以及弧数
    *GL = (GraphAdjList)malloc(sizeof(graphAdjList));
    (*GL)->numVertexes = G.numVertexes;
    (*GL)->numEdges = G.numEdges;
    
    //2. 从邻接矩阵中将顶点信息输入
    for (int i = 0; i < G.numVertexes; i++) {
        //顶点入度为0
        (*GL)->adjList[i].in = 0;
        //顶点信息
        (*GL)->adjList[i].data = G.vexs[i];
        //顶点边表置空
        (*GL)->adjList[i].firstedge = NULL;
    }
    
    //3. 建立边表
    EdgeNode *e;
    for (int i = 0; i < G.numVertexes; i++) {
        for (int j = 0; j < G.numVertexes; j++) {
            if (G.arc[i][j] == 1) {
             
                //创建边表中的邻近结点 i->j
                e = (EdgeNode *)malloc(sizeof(EdgeNode));
                //邻接序号为j
                e->adjvex = j;
                //将当前结点的指向adjList[i]的顶点边表上
                e->next = (*GL)->adjList[i].firstedge;
                (*GL)->adjList[i].firstedge = e;
                //顶点j 上的入度++;
                (*GL)->adjList[j].in++;
                
//                //创建边表中的邻近结点 j->i
//                e = (EdgeNode *)malloc(sizeof(EdgeNode));
//                //邻接序号为j
//                e->adjvex = i;
//                //将当前结点的指向adjList[i]的顶点边表上
//                e->next = (*GL)->adjList[j].firstedge;
//                (*GL)->adjList[j].firstedge = e;
//                //顶点j 上的入度++;
//                (*GL)->adjList[i].in++;
            }
        }
    }
}


Boolean visited[MAXSIZE]; /* 访问标志的数组 */
/* 邻接表的深度优先递归算法 */
void DFS(GraphAdjList GL, int i)
{
    EdgeNode *p;
    visited[i] = TRUE;
    
    //2.打印顶点 A
    printf("%c ",GL->adjList[i].data);
    
    p = GL->adjList[i].firstedge;
    
    //3.
    while (p) {
        if(!visited[p->adjvex])
            DFS(GL,p->adjvex);
        
        p = p->next;
    }
}

/* 邻接表的深度遍历操作 */
void DFSTraverse(GraphAdjList GL)
{
    //1. 将访问记录数组默认置为FALSE
    for (int i = 0; i < GL->numVertexes; i++) {
        /*初始化所有顶点状态都是未访问过的状态*/
        visited[i] = FALSE;
    }

    //2. 选择一个顶点开始DFS遍历. 例如A
    for(int i = 0; i < GL->numVertexes; i++)
        //对未访问过的顶点调用DFS, 若是连通图则只会执行一次.
        if(!visited[i])
            DFS(GL, i);
}

 验证

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("邻接表的深度优先遍历!\n");
    MGraph G;
    GraphAdjList GL;
    CreateMGraph(&G);
    CreateALGraph(G,&GL);


    DFSTraverse(GL);
    printf("\n");
    return 0;
}
邻接表的深度优先遍历!
A F G H E D I C B

 

邻接矩阵遍历结果 ：A B C D E F G H I

邻接表遍历结果：     A F G H E D I C B
邻接矩阵和邻接表同样的深度优先遍历，结果可能不一样（遍历的顶点顺序可能不一样）

 

shengdaVolleyball
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构中图的深度优先遍历算法与实现.pdf
08-07
#资源达人分享计划#
educoder数据结构与算法 图 第1关：实现图的宽度优先遍历
qq_54008392的博客
12-09 1万+
任务描述 本关任务：请你实现 graph.cpp 里的int Graph_WidthFirst(Graph*g, int start, Edge* tree)函数。 注意遵守约定：编号小的优先入队列。 相关知识 图 2 给出了对图 1 的无向图的存储结构图：每个顶点的名称由一个字符串描述，所有字符串的起始地址组织为一个数组，数组的起始地址为vetex；顶点的相邻关系保存在相邻矩阵中，其起始地址为adj，adj[i*n+j]的值为 1 表示i号顶点到j号顶点有边，为 0 表示无边，其中n是顶点个
头歌数据结构——图
weixin_62440328的博客
11-21 5741
【代码】头歌数据结构——图。
数据结构与算法-图的深度优先遍历【十六】
Riptide
08-16 1067
对于图的遍历，也分为深度优先遍历与广度优先遍历。 深度优先遍历：一条路走到黑，直到没有遍历过过的节点，那么回退，不然一直往下面走。 还是以之前的这个邻接矩阵为例： 以这个邻接矩阵为例： 图的定义： function Graph(vexs = [], arcs = []) { this.vexs = vexs this.arcs = arcs } vexs 存储了4个顶点： const vexs= [ 'A', 'B', 'C', 'D'] arcs是一个二维数组
数据结构 图的深度优先遍历算法
光金正博客
09-19 2348
邻接矩阵： #include &lt;iostream&gt; using namespace std; #define maxsizes 105 typedef int Type; // 顶点定义 typedef struct{ Type data; }vertex; // 邻接矩阵定义 typedef struct{ int n,e; ver...
数据结构与算法之图的深度优先遍历和广度优先遍历
lin1214000999的博客
03-15 3984
图是表示一种多对多关系的数据结构 它包括无向图，有向图，带权图 无向图：就是顶点之间的连线（边）没有方向箭头 有向图：就是顶点之间的连线（边）有方向箭头 带权图：就是顶点之间的连线（边）表明了大小如上海到北京的距离，北京到天津的距离类似的导航地图就是带权图 下图就是一个无向图： 字母所表示的是顶点，顶点间的连线叫做边 按照A,B,C,D,E,F,G的顺序添加节点，并添加对应的边构成下图 深度优...
Python算法系列—深度优先遍历算法【二叉树】
12-21
深度优先遍历算法之二叉树一、什么是深度优先遍历二、二叉树1. 二叉树简介2.二叉树类型3.二叉树相关术语4. 二叉树的节点代码5. 二叉树遍历顺序6.深度优先遍历和广度优先遍历三、面试题+励志 这不就是二叉树吗？嗯，...
数据结构与算法-C#版
03-09
这是C#版的数据结构与算法的代码实现，包括：顺序表，单链表，双链表；...用邻接矩阵解决图的编程问题，用邻接表解决图的编程问题，图的遍历（深度优先，广度优先），Dijkstra最短路径算法；冒泡排序，快速排序
数据结构实验报告-图的遍历.doc
07-11
验 报 告 实验：图的遍历 一、实验目的： 1、理解并掌握图的逻辑结构和物理结构——邻接矩阵、邻接表 2、掌握图的构造方法 3、掌握图的邻接矩阵、邻接表存储方式下基本操作的实现算法 4、掌握图的深度优先遍历和广度...
数据结构与算法-实验四二叉树
最新发布
11-19
初始化二叉树、按前序次序建立一个二叉树、检查二叉树是否为空、按任一种遍历次序（包括按前序、中序、后序、按层次）输出二叉树中的所有结点、求二叉树的深度、求二叉树中所有结点数、清除二叉树。
19、数据结构与算法 - 图 最小生成树（一）Prim算法
shengdaVolleyball的博客
06-01 320
最小生成树 什么是最小生成树，就是一个图中，将所有顶点连结并且其权重总和最小。 当然前提是图是一个连通图 1. Prim算法 1.1核心思路 从一个顶点出发，不断贪婪已知可以连接的最小权值边。 一个adjvex数组不断更新相连，且权值更小的顶点。 adjvex中是起点，adjuer[k] -> k 一个lowcost数组不断更新可选的最小权值，通过0标记已加入最小生成树。 lowcost 中存储 adjuex[k] --> k 的权值，新顶点指向k的权值..
超详细C语言版数据结构：图的深度优先遍历（推荐收藏）
「 刘一哥与GIS的故事」
06-25 1万+
文章目录一、邻接矩阵存储图的深度优先遍历过程分析二、结果分析三、C语言编程实现图的深度优先遍历四、图的遍历及其应用 一、邻接矩阵存储图的深度优先遍历过程分析 对图1这样的无向图，要写成邻接矩阵，则就是下面的式子： 一般要计算这样的问题，画成表格来处理是相当方便的事情，实际中计算机处理问题，也根本不知道所谓矩阵是什么，所以画成表格很容易帮助我们完成后面的编程任务。在我们前面介绍的内容中，有不少是借助着表格完成计算任务的，如Huffman树。 为了记录那些顶点是已经走过的，还要设计一个表来标记已经走过的顶
数据结构与算法-图（深度优先遍历dfs &广度优先遍历bfs）
slighting1128的博客
01-14 289
文章目录图一、优先遍历二、代码1.Graph2.Demo总结 图 一、优先遍历 二、代码 1.Graph 代码如下（示例）： Graph; //使用二维矩阵来表示图 import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; public class Graph { //用链表表示其中的节点的数据 public ArrayList<String> VertexLi
数据结构及算法基础 之图（四） 图的深度优先遍历
qigaohua的博客
10-31 890
文章目录一、深度优先遍历的递归定义二、基本实现思想三、示例测试     一、深度优先遍历的递归定义    假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的...
图的广度优先搜索（BFS）和深度优先搜索（DFS）算法解析
热门推荐
weixin_40953222的博客
06-02 16万+
BFS/DFS算法解析【算法入门]2018/6/21.前言和树的遍历类似，图的遍历也是从图中某点出发，然后按照某种方法对图中所有顶点进行访问，且仅访问一次。但是图的遍历相对树而言要更为复杂。因为图中的任意顶点都可能与其他顶点相邻，所以在图的遍历中必须记录已被访问的顶点，避免重复访问。根据搜索路径的不同，我们可以将遍历图的方法分为两种：广度优先搜索和深度优先搜索。2.图的基本概念2.1.无向图和无向...
拓扑排序_TopologicalSort
happylife1527的专栏
09-04 991
#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXEDGE 20 #define
图的深度优先遍历
zandaoguang的博客
08-16 1092
图的深度优先遍历又称为图的深度优先搜索。 本文章分为用邻接矩阵和邻接链表来进行图的深度优先遍历。可以用于个人学习，本人写博客的目的是便于复习和记录所学的重点和难点，所以不全请大家见谅 邻接矩阵 #include <stdio.h> #include <malloc.h> #define VERTEXNUM 5 void createGraph(int (*
数据结构——图的遍历之深度优先遍历（DFS算法）_全世界最可爱的王小帅_CSDN博客
ggaycat的博客
11-25 4719
数据结构——图的遍历之深度优先遍历 图的遍历一般分为深度优先遍历和广度优先遍历 下面我们要说的是深度优先遍历 1，我们首先选择一个顶点作为起始点，假设我们选择顶点v作为起始点，首先访问v，然后找v的邻接点，访问v的一个还未被访问过邻接点w1, 2，再以w1为起始点，然后去找w1的邻接点，访问w1的一个还未被访问过的邻接点w2，再以w2作为起始点继续往下访问… 3，如果我们访问到一个顶点，以他作为起始点选择他的邻接点时发现他的邻接点全部都被访问过或者说他没有邻接点了，这个时候就返回到这个顶点的上个顶点，以上个
【数据结构和算法】图的遍历（深度优先遍历DFS与广度优先遍历BFS）
Clichong
02-22 3293
图的遍历 遍历定义： （遍历的实质：找到每个顶点的邻接点的过程） 图的遍历特点 解决重复遍历方法 图的遍历 1、深度优先遍历 方法： 例子： （连通图的深度优先遍历类似于树的先跟遍历，走不动再往回退） 思想思路 （其中辅助数组visited[n]，一开始初始化为0，访问到就初始化为1。） 算法实现 代码如下： void DFS(AMraph G...
请用c语言实现数据结构图的深度优先遍历算法
04-17
好的，以下是用C语言实现数据结构图的深度优先遍历算法的代码示例： ``` #include #include #define MAX_VERTICES 100 typedef struct Vertex { int num; // 顶点编号 int visited; // 是否已被访问 struct ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值