图_邻接矩阵_DFS_BFS

最新推荐文章于 2022-04-10 14:31:01 发布
最新推荐文章于 2022-04-10 14:31:01 发布
阅读量734 收藏 3
点赞数 1
分类专栏： 数据结构与算法 文章标签： 图 c++ DFS BFS 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jwentao01/article/details/45937785
版权

图（Graph）由顶点的 有穷非空集合 和 顶点之间边的集合 组成。
表示为：G（V，E），G：图，V：图G中 顶点的集合，E：图G中 边的集合
图的邻接矩阵存储结构表述如下：

#define VEX_MAX 100              /*最大顶点数*/
typedef char Vtype;              /*顶点类型*/
typedef int Etype;               /*边的类型*/
typedef struct{
    Vtype vex[VEX_MAX];          /*顶点表*/
    Etype arc[VEX_MAX][VEX_MAX]; /*边表*/
    int Vex_num,Edg_num;         /*顶点数和边数*/
}Graph;                          /*图的结构体：邻接矩阵表示法*/

创建无向图：

void Creatgraph(Graph *g)        /*创建无向图*/
{
    int i,j,k;
    cout << "创建无向图:" << endl;
    cout << "Please input the Vex_num and Edg_num:" << endl;
    cin >> g->Vex_num >> g->Edg_num;

    cout << "输入顶点:" << endl;   /*初始化图结构体中第一个数组：顶点数组*/
    for(i = 0;i < g->Vex_num;i++)
        cin >> g->vex[i];

    cout << "输入各边情况:" << endl;/*初始化第二个数组：边数组，两点之间存在边的置为1，无边置为0*/
    for(i = 0;i < g->Vex_num;i++)
        for(j = 0;j < g->Vex_num;j++)
        {
            g->arc[i][j] = 0;
        }
    for(k = 0;k < g->Edg_num;k++)
    {
        cout << "please input the (vi,vi):" << endl;
        cin >> i >> j;
        g->arc[i][j] = 1;
        g->arc[j][i] = g->arc[i][j];
    }
}

DFS(Depth_First_Search，深度优先遍历)：类似树的前序遍历。
初始化时，图中各顶点均未被访问，从图中某个顶点(设为V0)出发，访问V0,然后搜索V0的一个邻接点Vi,若Vi未被访问，则访问之，再搜索Vi的一个邻接点(深度优先)
若某顶点的邻接点全部访问完毕，则回溯(Backtracking)到它的上一顶点，然后再从此顶点又按深度优先的方法搜索下去，…，直到能访问的顶点都访问完毕为止。
代码如下：

int visit[VEX_MAX];   /*visit数组由两个函数公有，需要放在外部*/
                     /*visit数组，标记该点是否被访问，已访问标1，未访问标0*/
void dfs(Graph *g,int i) /*DFS递归算法*/
{
    int j;
    cout << "被访问的点:" << i << ' ' << g->vex[i] << endl;
    visit[i] = 1;
    for(j = 0;j < g->Vex_num;j++)
    {
        if(g->arc[i][j] != 0 && visit[j] == 0)
            dfs(g,j);
    }
}

void DFS(Graph *g)   /*DFS遍历操作*/
{
    int i;
    //int visit[g->Vex_num]; // 容易犯错的地方
    for(i = 0;i < g->Vex_num;i++)
        visit[i] = 0;
    for(i = 0;i < g->Vex_num;i++)
    {
        if(visit[i] == 0) /*若未被访问，进行搜索*/
            dfs(g,i);
    }
}

BFS(Breadth_First_Search，广度优先遍历):类似树的按层次遍历。
初始时，图中各顶点均未被访问，从图中某顶点(V0)出发，访问V0,并依次访问V0的各邻接点(广度优先)。
然后，分别从这些被访问过的顶点出发，扔仍按照广度优先的策略搜索其它顶点,….,直到能访问的顶点都访问完毕为止。
代码如下：

int visit2[VEX_MAX];
void bfs(Graph *g,int i)   /*BFS递归算法*/
{
    int j,k;
    cout << "被访问的点:" << i << ' ' << g->vex[i] << endl;
    visit2[i] = 1;     /*已访问过的赋1*/
    queue<int> q;      /*定义一个队列q*/
    q.push(i);         /*将传递进来的值i入栈*/
    while(!q.empty())  /*若队列非空，q.empty()函数判定队列是否为空，为空则返回真*/
    {
        j = q.front(); /*返回队列头部数据，赋给j*/
        q.pop();       /*将队列中头部数据出队列*/
        for(k = 0;k < g->Vex_num;k++)
        {
            if(visit2[k] == 0 && g->arc[j][k] != 0)
            {
                cout << "被访问的点:" << k << ' ' << g->vex[k] << endl;
                visit2[k] = 1;
                q.push(k);
            }
        }
    }

}
void BFS(Graph *g)    /*BFS遍历操作，和DFS遍历操作类似*/
{
    int i;
    for(i = 0;i < g->Vex_num;i++)
        visit2[i] = 0;
    for(i = 0;i < g->Vex_num;i++)
    {
        if(visit2[i] == 0)
            bfs(g,i);
    }
}

总代码如下：

#include <iostream>
#include <queue>

using namespace std;

#define VEX_MAX 100              /*最大顶点数*/
typedef char Vtype;              /*顶点类型*/
typedef int Etype;               /*边的类型*/
typedef struct{
    Vtype vex[VEX_MAX];          /*顶点表*/
    Etype arc[VEX_MAX][VEX_MAX]; /*边表*/
    int Vex_num,Edg_num;         /*顶点数和边数*/
}Graph;                          /*图的结构体：邻接矩阵表示法*/
/*******************************************************************/
void Creatgraph(Graph *g)        /*创建无向图*/
{
    int i,j,k;
    cout << "创建无向图:" << endl;
    cout << "Please input the Vex_num and Edg_num:" << endl;
    cin >> g->Vex_num >> g->Edg_num;

    cout << "输入顶点:" << endl;       /*初始化图结构体中第一个数组：顶点数组*/
    for(i = 0;i < g->Vex_num;i++)
        cin >> g->vex[i];

    cout << "输入各边情况:" << endl;   /*初始化第二个数组：边数组，两点之间存在边的置为1，无边置为0*/
    for(i = 0;i < g->Vex_num;i++)
        for(j = 0;j < g->Vex_num;j++)
        {
            g->arc[i][j] = 0;
        }
    for(k = 0;k < g->Edg_num;k++)
    {
        cout << "please input the (vi,vi):" << endl;
        cin >> i >> j;
        g->arc[i][j] = 1;
        g->arc[j][i] = g->arc[i][j];
    }
}

void Printarc(Graph *g)    /*输出顶点数组and邻接矩阵*/
{
    int i,j;
    cout << "The vex[]:" << endl;
    for(i = 0;i < g->Vex_num;i++)
        cout << g->vex[i] << ' ';
    cout << '\n';
    cout << "The arc[][]:" << endl;
    for(i = 0;i < g->Vex_num;i++)
    {
        for(j = 0;j < g->Vex_num;j++)
        {
            cout << g->arc[i][j] << ' ';
        }
        cout << '\n';
    }
    cout << '\n';
}
/*******************************************************************/
/*DFS(Depth_First_Search)：类似树的前序遍历。*/
int visit[VEX_MAX];   /*visit数组由两个函数公有，需要放在外部*/
                     /*visit数组，标记该点是否被访问，已访问标1，未访问标0*/
void dfs(Graph *g,int i) /*DFS递归算法*/
{
    int j;
    cout << "被访问的点:" << i << ' ' << g->vex[i] << endl;
    visit[i] = 1;
    for(j = 0;j < g->Vex_num;j++)
    {
        if(g->arc[i][j] != 0 && visit[j] == 0)
            dfs(g,j);
    }
}

void DFS(Graph *g)   /*DFS遍历操作*/
{
    int i;
    //int visit[g->Vex_num];
    for(i = 0;i < g->Vex_num;i++)
        visit[i] = 0;
    for(i = 0;i < g->Vex_num;i++)
    {
        if(visit[i] == 0) /*若未被访问，进行搜索*/
            dfs(g,i);
    }
}
/*******************************************************************/
/*BFS(Breadth_First_Search):类似树的按层次遍历。*/
int visit2[VEX_MAX];
void bfs(Graph *g,int i)   /*BFS递归算法*/
{
    int j,k;
    cout << "被访问的点:" << i << ' ' << g->vex[i] << endl;
    visit2[i] = 1;     /*已访问过的赋1*/
    queue<int> q;      /*定义一个队列q*/
    q.push(i);         /*将传递进来的值i入栈*/
    while(!q.empty())  /*若队列非空，q.empty()函数判定队列是否为空，为空则返回真*/
    {
        j = q.front(); /*返回队列头部数据，赋给j*/
        q.pop();       /*将队列中头部数据出队列*/
        for(k = 0;k < g->Vex_num;k++)
        {
            if(visit2[k] == 0 && g->arc[j][k] != 0)
            {
                cout << "被访问的点:" << k << ' ' << g->vex[k] << endl;
                visit2[k] = 1;
                q.push(k);
            }
        }
    }

}
void BFS(Graph *g)    /*BFS遍历操作，和DFS遍历操作类似*/
{
    int i;
    for(i = 0;i < g->Vex_num;i++)
        visit2[i] = 0;
    for(i = 0;i < g->Vex_num;i++)
    {
        if(visit2[i] == 0)
            bfs(g,i);
    }
}
/*******************************************************************/
int main()
{
    Graph *g;
    g = new(Graph);
    Creatgraph(g);
    Printarc(g);
    cout << "DFS:" << endl;
    DFS(g);
    cout << "BFS:" << endl;
    BFS(g);
    delete g;  /*注意：new和delete不需要头文件，它不同于malloc和free*/
    return 0;
}

结果如下：
这里写图片描述
这里写图片描述
/点滴积累，我的一小步O(∩_∩)O~/

停5s
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
邻接矩阵表示图的深度优先遍历（DFS）
weixin_51002828的博客
05-18 6331
邻接矩阵表视图的深度优先搜索遍历 文章目录 一、邻接矩阵表示图 二、采用临界矩阵表示图，创建无向图 三、深度优先遍历（DFS） 四、完整代码实现 五、结果样例 一、邻接矩阵表示图 typedef struct { char vexs[MVNum]; //顶点表 int arcs[MVNum][MVNum]; //邻接矩阵 int vexnum, arcnum; //图当前的点...
无向图邻接表的深度优先遍历(DFS)
flying0033的专栏
11-15 8276
邻接表是图的一种链式存储结构。对图的每个顶点建立一个单链表（n个顶点建立n个单链表）   头文件:Graph.h #ifndef GRAPH_H #define GRAPH_H #define MAXSIZE 50 typedef char VertexType; //顶点数据类型 typedef int EdgeType; //边权值类型 typedef struct edge
图的邻接矩阵、邻接表存储和图的广度优先搜索（BFS）、深度优先搜索（DFS）
Dong_HFUT的博客
04-10 7659
图的邻接矩阵和邻接表表示。广度优先搜索（BFS）、深度优先搜索（DFS）及 C++ 实现。
DFS（邻接矩阵）
戒
12-04 599
#include <stdio.h> #include<string.h> #include<stdlib.h> #include<time.h> const int Len=105; typedef struct SNode* Stack; struct SNode { int data; struct SNode* next; };//栈 typedef struct Node{ int nv;//点 int ne;//边 i
图的遍历c语言程序,不知有没有人有c的图遍历算法实现的函数
weixin_33345160的博客
05-17 111
转自:http://blog.zjol.com.cn/user2/21459/archives/2007/111652.shtml图的遍历算法程序图的遍历是指按某条搜索路径访问图中每个结点，使得每个结点均被访问一次，而且仅被访问一次。图的遍历有深度遍历算法和广度遍历算法，程序如下：＃i nclude ＃i nclude #define INFINITY 32767#define MAX_VEX 2...
DFS_BFS.zip_邻接矩阵_邻接矩阵结构
09-23
在提供的文件"DFS_BFS.c"中，我们可以预见到它包含了C语言实现的DFS和BFS算法，使用邻接矩阵作为图的表示。学习这个代码可以帮助我们更好地理解这两种搜索算法在实际编程中的应用，以及如何优化内存和时间效率。通过...
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
- `8.7-8.9 MattoList Prim Dijkstra.cpp`：这个文件可能包含了将图表示为邻接矩阵，以及实现Prim算法和Dijkstra算法的代码。Prim算法用于找到加权无向图的最小生成树，而Dijkstra算法是单源最短路径问题的一种解决...
邻接矩阵.zip_生成邻接矩阵_邻接_邻接矩阵
07-14
学习和理解邻接矩阵对于深入理解和应用图论算法至关重要，例如深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径问题（如Dijkstra算法、Floyd-Warshall算法）等。因此，这个资料包对于学习图论和相关算法的初学者或者...
ch7.rar_创建邻接矩阵_邻接矩阵_邻接矩阵c＋＋_邻接表
09-21
邻接矩阵适用于快速查询任意两个节点间是否存在边（时间复杂度O(1)），而邻接表更适合进行遍历操作，如深度优先搜索（DFS）和广度优先搜索（BFS）。 文件"ch7.cpp"可能包含了邻接矩阵和邻接表的C++实现代码，包括...
tu.zip_tu_邻接矩阵做图_邻接表做图
09-21
在`tu.cpp`这个文件中，很可能是实现了上述的邻接矩阵和邻接表做图的方法，并且包含了BFS和DFS的代码。通过阅读和理解这段代码，你可以进一步了解这两种图的存储方式以及遍历算法的具体实现。 总结起来，邻接矩阵和...
1142-图的遍历——深度优先搜索
weixin_45768308的博客
09-09 528
题目描述 深度优先搜索遍历类似于树的先根遍历，是树的先根遍历的推广。其过程为：假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可以从图中的某个顶点v出发，访问此顶点，然后依次从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作为起始点，重复上述过程，直至图中所有顶点都被访问到为止。 其算法可以描述如下： 在本题中，读入一个无向图的邻接矩阵（即数组表示），建立无向图并按照以上描述中的算法遍历所有顶点，输出遍历顶
邻接矩阵图的dfs和bfs
NameiCc
06-14 496
int G[maxn][maxn]; int n; //点数 int m; //边数 int vis[maxn]; void init() { memset(G,0,sizeof(G)); memset(vis,0,sizeof(vis)); for(int i=0; i<m; i++) { int u,v; scanf("%d%d"
图的遍历（DFS、BFS）使用邻接矩阵（数组）作为存储结构--C语言
haofight的博客
01-17 5895
#include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <limits.h>#define MAX_VERTEX_NUM 20 //最大顶点个数 #define INFINITY INT_MAX //最大值∞ typedef char VertexType; //顶点向量类型 typedef int V
图的遍历（DFS）
m0_53157173的博客
03-20 5438
DFS：深度优先遍历 图的遍历操作 如何选择遍历的起始节点 从某个起点始可能到达不了所有的节点，怎么办？ 广度优先遍历 伪代码 邻接矩阵的方式 图的深度优先遍历递归算法 void Graph::DFS(int v) { //当前节点被访问过的标志 visit[v] = 1; //访问当前节点 cout << vertex[v] << endl; //对顶点在边表中该行的所有边关系进行遍历，如果==1表示是邻接点，并且还要判断当前顶点是否被访问过 for (in
DFS和BFS的实现（邻接矩阵、邻接表）
wmy0217_的博客
02-18 2355
文章目录DFS和BFS的实现（邻接矩阵）DFS和BFS的实现（邻接表） DFS和BFS的实现（邻接矩阵） #include<iostream> #include<queue> using namespace std; #define OK 1 #define Maxint 0 typedef int status ; bool visited[10]; typedef ...
数据结构——深度优先遍历DFS（实现邻接矩阵表示的无向连通图）
qq_59708493的博客
02-09 1703
1.DFS的介绍 //邻接矩阵表示的无向图遍历实现。 #include<iostream> using namespace std; #define MAX_SIZE 100//最大顶点数 。 #define MAX_INT 326564//表示极大值，即 ∞ 。 typedef char Elemtype_A;//定义顶点的数据类型为字符型 。 typedef int Elemtype_S;//定义边的权值为整型 。 /*深度优先遍历（DFS） 方法： (1)在访问图中某一起始顶点 ν后，
图的遍历——DFS（邻接矩阵）
weixin_33901926的博客
03-25 113
递归 + 标记 一个连通图只要DFS一次，即可打印所有的点。 #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include <malloc.h> using namespace std; const in...
图——DFS,BFS（邻接矩阵）
wind_waves的博客
06-27 805
DFS你可以当成树的先根遍历来做，BFS你可以当做树的层次遍历来做，这里因为图不一定是连通图，所以每个顶点都要尝试一下，用一个BOOL数组来表示这个顶点是否经历过遍历。（这个编辑器插入代码段为啥只能是黑色） #include<iostream> #include<queue> using namespace std; typedef char VertexType; typedef int EdgeType; const int MAXVEX = 100; c
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、付费专栏及课程。

余额充值