图的遍历-邻接矩阵实现DFS和BFS，c语言实现

最新推荐文章于 2024-03-05 19:56:46 发布
最新推荐文章于 2024-03-05 19:56:46 发布
阅读量4.9k 收藏 41
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrs_fanshuishui/article/details/81609568
版权

首先是我个渣对两种遍历方法的看法

BFS:寻找最优解,比如最短路径.时间复杂度更低，一圈一圈搜索,深度不大的时候比较适用，但是

DFS:不撞南墙不回头,所以相对于BFS 找到的不一定是最优解,但是其对于空间的消耗较少,因为不需要存储临时节点

 

对于DFS，其实现方法类似于先序遍历，不断递归的调用DFS函数，依次向下搜寻。

 

首先是图结构体的实现

struct GNode
{   int Nv;//顶点数
    int Ne;//边数
    int G[MaxSize][MaxSize];
};
typedef PtrToGNod MGraph;//图

typedef struct ENode *PtrToENod;
struct ENode{
    Vertex V1,V2;
    int Weigth;//权重
};
typedef PtrToENod Edge;//边

图的构建函数

MGraph CreatGraph(int size)//创建一个无边的图
{
    MGraph Graph = (MGraph)malloc(sizeof(struct GNode));//给图分配存储空间
    Graph->Nv = size;
    Graph->Ne = 0;
    for (int i = 0; i<Graph->Nv; i++) {
        for (int j = 0; j<Graph->Nv; j++) {
            Graph->G[i][j] = 0;
        }
    }
    return Graph;
}

void InsertEdge(MGraph G,Edge E)
{
    G->G[E->V1][E->V2] = E->Weigth;
    //如果是无向图
    G->G[E->V2][E->V1] = E->Weigth;
}
MGraph BuildGraph(int Nv)
{
    MGraph Graph;
    Graph = CreatGraph(Nv);
    cout<<"请输入边的个数";
    cin>>Graph->Ne;
    if (Graph->Ne!=0) {
        Edge E = (Edge)malloc(sizeof(struct ENode));
        cout<<"依次输入节点1，2和权重"<<endl;
        for (int i = 0; i<Graph->Ne; i++) {
            cin>>E->V1>>E->V2>>E->Weigth;
            InsertEdge(Graph, E);
        }
    }
    return Graph;
}

图建立完后

实现DFS深度优先遍历搜索

void DFS(MGraph G,Vertex V)//深度优先遍历搜索,从V节点开始
{
    int W;
    /*以V为出发点对周围进行DFS搜索*/
    cout<<"正在深度优先遍历第"<<v<<"个节点";
    Visited[V] = true;//标记为以访问
    for(W = 0;W<G->Nv;W++)
    {
        if (!Visited[W] && IsEdge(G, V, W)) {
            DFS(G,W);
        }
    }
    
}

 首先声明一个Visited数组，初始化为全false，每当标记一个节点后(即访问后),将标记位置1,表示完成访问,然后访问当前节点的领节点，如果该节点未被访问，依次调用DFS向下进行.

对于所有节点的深度优先遍历,定一个一个函数，完成对所有节点的深度优先遍历，以满足万一有节点与其他节点都不联通的情况

void DFSTraverseM(MGraph G)//深度优先遍历所有节点
{
    int i;
    for(i = 0;i<G->Nv;i++)
    {
        Visited[i] = false;
    }
    for (i=0; i<G->Nv; i++) {//这个语句是对与矩阵中所有元素都进行深度优先遍历搜索
        if (!Visited[i])
        DFS(G, i);
    }
}

 以上完成了对所有节点的深度优先遍历

 

对于BFS，广度优先搜索，类似于树的层次遍历，所以用队列实现是一个不错的方法，但不仅仅只能用队列实现，这里为了方便，我选择了队列实现，首先是构造结构体,并完成相关实现的函数

ypedef struct QNode *Queue;
struct QNode{
    int front;
    int rear;
    int *data;
    int maxsize;
};

Queue CreateQueue(int size)//创建队列
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->data = (int *)malloc(size*sizeof(int));
    Q->front = Q->rear = 0;
    Q->maxsize = size;
    return Q;
}

bool IsFull(Queue Q)
{
    if((Q->rear+1)%Q->maxsize == Q->front)
    {
        cout<<"队列满";
        return true;
    }
    return false;
}

void AddQ(Queue Q,int x)
{
    if (IsFull(Q)){
        cout<<"已满";
    }
    else{
        Q->rear = (Q->rear+1)%Q->maxsize;
        Q->data[Q->rear] = x;
    }
}

bool IsEmpty(Queue Q)
{
    return (Q->front == Q->rear);
}

int DeletQueue(Queue Q)
{
    int x;
    if (IsEmpty(Q)) {
        cout<<"队列空";
        return -1;
    }
    else
    {
        x = Q->data[Q->front];
        Q->front = (Q->front+1)%Q->maxsize;
        return x;
    }
}

实现队列后，来考虑BFS，广度优先搜索，依次搜索该节点周围所有节点，并置于队列当中，每当队列中的一个元素弹出，依次访问其周边所有节点，其原理近似于树的层次遍历。

void BFM(MGraph G,Vertex V)//广序遍历
{
    int i,j;
    Queue Q = CreateQueue(MaxSize);
    cout<<"正在广度优先遍历第"<<V<<"个节点"<<endl;
    Visited[V] = true;
    AddQ(Q, V);//将v压入队列
    while (!IsEmpty(Q)) {
        i = DeletQueue(Q);
        for (j = 0; j<G->Nv; j++) {
            if (G->G[i][j] !=0 && !Visited[j]) {
               cout<<"当前正在广度优先遍历第"<<j<<"个节点"
                Visited[j] = true;//将i周围的存在的节点依次标记
                AddQ(Q,j);//将j推入队列内 s
            }
        }
    }
}

void BFTraver(MGraph G)
{
    int i;
    for (i = 0; i<G->Nv; i++) {
        Visited[i] = 0;
    }
    for (i = 0; i<G->Nv; i++) {
        if (!Visited[i])
        BFM(G, i);
    }
}

 不难看出，广度优先遍历一层一层搜索，而深度优先遍历不撞南墙不回头，但两种遍历都非常的棒,对于学习数据结构很有帮助

以下是全部代码实现

 

#include <iostream>
using namespace std;
typedef struct GNode *PtrToGNod;
#define MaxSize 10
#define Vertex int
bool Visited[MaxSize];
struct GNode
{   int Nv;//顶点数
    int Ne;//边数
    int G[MaxSize][MaxSize];
};
typedef PtrToGNod MGraph;//图

typedef struct ENode *PtrToENod;
struct ENode{
    Vertex V1,V2;
    int Weigth;//权重
};
typedef PtrToENod Edge;

typedef struct QNode *Queue;
struct QNode{
    int front;
    int rear;
    int *data;
    int maxsize;
};

Queue CreateQueue(int size)//创建队列
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->data = (int *)malloc(size*sizeof(int));
    Q->front = Q->rear = 0;
    Q->maxsize = size;
    return Q;
}

bool IsFull(Queue Q)
{
    if((Q->rear+1)%Q->maxsize == Q->front)
    {
        cout<<"队列满";
        return true;
    }
    return false;
}

void AddQ(Queue Q,int x)
{
    if (IsFull(Q)){
        cout<<"已满";
    }
    else{
        Q->rear = (Q->rear+1)%Q->maxsize;
        Q->data[Q->rear] = x;
    }
}

bool IsEmpty(Queue Q)
{
    return (Q->front == Q->rear);
}

int DeletQueue(Queue Q)
{
    int x;
    if (IsEmpty(Q)) {
        cout<<"队列空";
        return -1;
    }
    else
    {
        x = Q->data[Q->front];
        Q->front = (Q->front+1)%Q->maxsize;
        return x;
    }
}

MGraph CreatGraph(int size)//创建一个无边的图
{
    MGraph Graph = (MGraph)malloc(sizeof(struct GNode));//给图分配存储空间
    Graph->Nv = size;
    Graph->Ne = 0;
    for (int i = 0; i<Graph->Nv; i++) {
        for (int j = 0; j<Graph->Nv; j++) {
            Graph->G[i][j] = 0;
        }
    }
    return Graph;
}

void InsertEdge(MGraph G,Edge E)
{
    G->G[E->V1][E->V2] = E->Weigth;
    //如果是无向图
    G->G[E->V2][E->V1] = E->Weigth;
}
MGraph BuildGraph(int Nv)
{
    MGraph Graph;
    Graph = CreatGraph(Nv);
    cout<<"请输入边的个数";
    cin>>Graph->Ne;
    if (Graph->Ne!=0) {
        Edge E = (Edge)malloc(sizeof(struct ENode));
        cout<<"依次输入节点1，2和权重"<<endl;
        for (int i = 0; i<Graph->Ne; i++) {
            cin>>E->V1>>E->V2>>E->Weigth;
            InsertEdge(Graph, E);
        }
    }
    return Graph;
}
void visit(Vertex V)//访问
{
    cout<<"正在访问第"<<V<<"个节点"<<endl;
}
bool IsEdge(MGraph G,Vertex V,Vertex W)
{
     if(G->G[V][W]!=0 || G->G[W][V]!=0)//无向图
         return true;
         return false;
}

void DFS(MGraph G,Vertex V)//深度优先遍历搜索,从V节点开始
{
    int W;
    /*以V为出发点对周围进行DFS搜索*/
   cout<<"正在深度优先遍历第"<<V<<"个节点"<<endl;
    Visited[V] = true;//标记为以访问
    for(W = 0;W<G->Nv;W++)
    {
        if (!Visited[W] && IsEdge(G, V, W)) {
            DFS(G,W);
        }
    }
    
}
void DFSTraverseM(MGraph G)//深度优先遍历所有节点
{
    int i;
    for(i = 0;i<G->Nv;i++)
    {
        Visited[i] = false;
    }
    for (i=0; i<G->Nv; i++) {//这个语句是对与矩阵中所有元素都进行深度优先遍历搜索
        if (!Visited[i])
        DFS(G, i);
    }
}
void BFM(MGraph G,Vertex V)//广序遍历
{
    int i,j;
    Queue Q = CreateQueue(MaxSize);
    cout<<"正在广度优先遍历第"<<V<<"个节点"<<endl;
    Visited[V] = true;
    AddQ(Q, V);//将v压入队列
    while (!IsEmpty(Q)) {
        i = DeletQueue(Q);
        for (j = 0; j<G->Nv; j++) {
            if (G->G[i][j] !=0 && !Visited[j]) {
                cout<<"正在广度优先遍历第"<<j<<"个节点"<<endl;
                Visited[j] = true;//将i周围的存在的节点依次标记
                AddQ(Q,j);//将j推入队列内 s
            }
        }
    }
}

void BFTraver(MGraph G)
{
    int i;
    for (i = 0; i<G->Nv; i++) {
        Visited[i] = 0;
    }
    for (i = 0; i<G->Nv; i++) {
        if (!Visited[i])
        BFM(G, i);
    }
}


int main(int argc, const char * argv[]) {
    // insert code here...
    int Nv;
    cout<<"请输入节点个数";
    cin>>Nv;
    MGraph Graph=BuildGraph(Nv);
    DFSTraverseM(Graph);
    cout<<"广度优先遍历"<<endl;
    BFTraver(Graph);
    return 0;
}

 

Mr_fanshuishui
关注
  • 3
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接矩阵存储和广度、深度优先遍历的方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6 abcde 0 1 1 0 2 1 0 3 1 2 3 1 2 4 1 1 4 1 输入结束（此行不必输入） 注：0 1 1表示该图的第0个顶点和第1个定点有边相连，如上图中的a->b所示       0 2 1表示该图的第0个顶点和第2个定点有边相连，如上图中的a->c所示       2 3 1表示该图的第2个顶点和第3个定点有边相连，如上图中的c->d所示
C语言实现图的邻接矩阵存储操作
08-27
主要为大家详细介绍了C语言实现图的邻接矩阵存储操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言数据结构与算法——深度、广度优先搜索（DFS、BFS）
最新发布
qing_tong_tong的博客
03-05 2249
深度优先搜索（Depth-First Search，DFS）和广度优先搜索（Breadth-First Search，BFS）是两种常见的图遍历算法，它们在C语言中被广泛应用于解决各种数据结构和算法问题。这两种搜索算法都用于遍历图或树中的节点，以便查找特定的目标或执行其他相关任务。
邻接矩阵，邻接表实现图的创建，遍历(DFS,BFS)
05-12
分别以邻接矩阵和邻接表的方式实现图的深度优先搜索、广度优先搜索
新建 DOC 文档_实现图的邻接矩阵和邻接表存储_doc_图的遍历算法_
10-01
领会图的两种主要存储结构、图基本运算算法和两种遍历算法设计内容：编写一个程序，设计带权图的邻接矩阵与邻接表的创建和输出运算，并在此基础上设计一个主程序完成如下功能：（1）建立如图所示的有向图G的邻接矩阵，并输出之（2）建立如图所示的有向图G的邻接表，并输出之（3）输出如图所示的有向图G从顶点0开始的深度优先遍历序列（4）输出如图所示的有向图G从顶点0开始的广度优先遍历序列（5）销毁图G的邻接表
数据结构-c语言-带main函数-图7.3-图的遍历-深度优先搜索-递归方法-邻接矩阵-有向图。
06-24
应用cfree软件，采用递归方法，基于有向图的邻接矩阵，进行深度优先搜索遍历（包括连通性）。
网状结构（图）图的存储（邻接矩阵、邻接表）、图的遍历（深度DFS、广度BFS）、图的最短路径
巫山♔
05-21 2800
图 多对多关系 是一种网状数据结构，图是由非空的顶点集合和一个描述顶点之间关系的集合组成 其定义 Graph = (V, E) V={x | x ∈某个数据对象} E = {<u, v> | P(u ,v) ∧ (u, v∈V )} V是具有相同特性的数据元素的集合，V中的数据元素通常称为顶点（Vertex） E是两个顶点之间关系的集合。P(u, v) 表示u和v之间有特定的关联属性 若<u，v>∈E，则<u，v>表示从顶点u的一条弧，并称u为弧尾或起始点，称
数据结构（廿五） -- C语言版 -- 图 - 图的遍历 -- 邻接矩阵 - 深度/广度优先遍历/搜索（DFS、BFS）
青椒*^_^*凤爪爪的博客
12-08 6344
图是一种非线性的数据结构，图的遍历指的是：从图中的某一顶点出发，沿着一些边访问图中所有的顶点，使得每个顶点都被访问且仅被访问一次。根据遍历路径的不同，通常有两种遍历图的方法：深度优先遍历(Depth First Search)和广度优先遍历(Breadth First Search)。它们对无向图和有向图都适用，图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。
图的创建（邻接表/邻接矩阵）、遍历（DFS、BFS）与最短路径（Dijkstra/Floyd）算法
qq_43522419的博客
09-24 1746
目录 一、图的创建 1.邻接矩阵 2.邻接表 3.邻接矩阵与邻接表的区别总结 二、图的遍历 1.深度优先DFS(使用递归） 2.广度优先BFS(使用队列) 3.DFS与BFS的比较 三、最短路径求解 1.迪杰斯特拉算法(Dijkstra) 2.弗洛伊德算法(Floyd) 3.Dijkstra与Floyd的比较 图的创建 1.邻接矩阵 ...
dfs算法c语言 寻路,递归2寻路之dfs
weixin_30068877的博客
05-25 363
练习：1给定一个迷宫矩阵,入口,出口,输出走出迷### 宫的所有路径代码:public class P1 {static int m=4,n=6;int[][] map= {{1,1,1,1,1,1},{0,1,0,1,0,1},{1,1,0,1,0,1},{1,1,1,1,1,1}};int dir[][]= {{1,0},{0,1},{-1,0},{0,-1}};int arr[]=new i...
使用邻接矩阵存储结构，求无向图中任意两点间所有的路径和路径条数
m0_61790474的博客
11-25 1090
#include <stdio.h> #include <iostream> #include <vector> using namespace std; #define Infinity 32766 #define MaxVertexNum 50 typedef struct AMGraph { char vex[MaxVertexNum]; int arc[MaxVertexNum][MaxVertexNum]; int vexnum, arcnum;
深度优先搜索（DFS）与宽度优先搜索（BFS）解析及例题_c语言
weixin_45865773的博客
02-08 1970
深度优先搜索（DFS） 宽度优先搜索（BFS） c语言解题 相关例题 部分和问题 Lake Counting问题 迷宫的最短路径
C语言实现DFS和BFS
LoadingCreate的博客
10-25 656
DFS（深度优先搜索）和BFS（广度优先搜索）是图论中常用的两种搜索方式。下面将介绍如何使用C语言实现DFS和BFS算法。
图的遍历——深度优先搜索（DFS）与广度优先搜索（BFS）（附带C语言源码）
weixin_73602725的博客
05-10 2811
在此之前我们学习过了图的一些基本概念，如同在二叉树中我们有前序遍历，中序遍历，后序遍历一般，在图中也有两种特殊的遍历方式——深度优先遍历与广度优先遍历。
决战11月之--------数据结构终章（图）
qq_61531066的博客
04-02 543
\图的概念 图是由顶点集V和边集E组成，记作G=(V, E) G：Graphic图形 V：Vertex 顶点 E：Edge 边
散步（dfs，邻接矩阵法）
weixin_63484669的博客
10-28 1863
6
DFS——矩阵中的路径
jingsuwen1的博客
05-29 828
题目描述 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符
C语言用DFS实现找到图的所有路径（邻接矩阵实现）
cysisu的博客
11-01 9525
链接：https://blog.csdn.net/hackersuye/article/details/79044555这里详细介绍了DFS遍历的过程，我主要是介绍实现 以下是例子，所有图的DFS遍历，只需要修改createGraphics()函数即可，即生成自己的map（邻接矩阵）,就可以找到两个点之间所有的路径。 1.问题如下： 输入一个矩阵的行数r（5-10）与列数c（5-10），生成...
c语言写邻接矩阵的最短路径的Dijkstra算法（附有详细代码）
qq_62185081的博客
12-29 2366
(1) 用dis数组来存储源点1到其他顶点的初始路径，标记1号顶点，此时dis数组中的值称为最短路径的估计值。(2) 从dis数组中找出离源起点最近的点2号，以2号顶点为源点进行找最近的顶点。把2号顶点标记，表示已经有最小值。
c语言邻接矩阵bfs和dfs
12-08
以下是C语言中邻接矩阵实现的BFS和DFS算法的示例代码： BFS算法： ```c #include <stdio.h> #include <stdlib.h> #define MaxInt 32767 #define MVNum 100 typedef char VerTexType; typedef int ArcType; typedef struct { VerTexType vexs[MVNum]; ArcType arcs[MVNum][MVNum]; int vexnum, arcnum; } AMGraph; int visited[MVNum]; void BFS(AMGraph G, int v) { int queue[MVNum], front = 0, rear = 0; int i, j, w; printf("%c ", G.vexs[v]); visited[v] = 1; queue[rear++] = v; while (front != rear) { i = queue[front++]; for (j = 0; j < G.vexnum; j++) { if (G.arcs[i][j] != MaxInt && !visited[j]) { printf("%c ", G.vexs[j]); visited[j] = 1; queue[rear++] = j; } } } } int main() { AMGraph G; int i, j; printf("请输入顶点数和边数："); scanf("%d%d", &G.vexnum, &G.arcnum); printf("请输入顶点信息："); for (i = 0; i < G.vexnum; i++) { scanf("%c", &G.vexs[i]); } printf("请输入邻接矩阵："); for (i = 0; i < G.vexnum; i++) { for (j = 0; j < G.vexnum; j++) { scanf("%d", &G.arcs[i][j]); if (G.arcs[i][j] == 0) { G.arcs[i][j] = MaxInt; } } } printf("请输入遍历起点："); int v; scanf("%d", &v); printf("BFS遍历结果："); BFS(G, v); return 0; } ``` DFS算法： ```c #include <stdio.h> #include <stdlib.h> #define MaxInt 32767 #define MVNum 100 typedef char VerTexType; typedef int ArcType; typedef struct { VerTexType vexs[MVNum]; ArcType arcs[MVNum][MVNum]; int vexnum, arcnum; } AMGraph; int visited[MVNum]; void DFS(AMGraph G, int v) { int i; printf("%c ", G.vexs[v]); visited[v] = 1; for (i = 0; i < G.vexnum; i++) { if (G.arcs[v][i] != MaxInt && !visited[i]) { DFS(G, i); } } } int main() { AMGraph G; int i, j; printf("请输入顶点数和边数："); scanf("%d%d", &G.vexnum, &G.arcnum); printf("请输入顶点信息："); for (i = 0; i < G.vexnum; i++) { scanf("%c", &G.vexs[i]); } printf("请输入邻接矩阵："); for (i = 0; i < G.vexnum; i++) { for (j = 0; j < G.vexnum; j++) { scanf("%d", &G.arcs[i][j]); if (G.arcs[i][j] == 0) { G.arcs[i][j] = MaxInt; } } } printf("请输入遍历起点："); int v; scanf("%d", &v); printf("DFS遍历结果："); DFS(G, v); return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值