第七章 图（邻接矩阵和邻接表建立图并实现DFS、BFS）

最新推荐文章于 2024-05-30 14:38:37 发布
最新推荐文章于 2024-05-30 14:38:37 发布
阅读量4.1k 收藏 27
点赞数 5
分类专栏： 数据结构基础记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccnuacmhdu/article/details/78746634
版权

邻接矩阵建立图并实现图的深度优先遍历和广度优先遍历

/*
    邻接矩阵实现图的广搜和深搜
*/

#include<iostream>
#include<queue>
#define inf 1000000 //假设的无穷大
#define vertex_max_num 100  //设的最大顶点数

using namespace std;

typedef struct {
    int v[vertex_max_num];//顶点名称
    int adj_matrix[vertex_max_num][vertex_max_num];//邻接矩阵
    int v_num, arc_num;//顶点数，弧数
    int kind;//图的种类,0有向图，1有向网，2无向图，3无向网
}graph;

int vis[vertex_max_num+1];//标志数组
//标志数组初始化
void init() {
    memset(vis, 0, sizeof(vis));
}

//创建有向图
void dir_graph_create(graph &G) {
    cout << "请输入要创建的有向图的顶点数和弧数："; cin >> G.v_num >> G.arc_num;
    //结点初始化
    for (int i = 1; i <= G.v_num; i++) G.v[i] = i;//对结点编号
    for (int i = 1; i <= G.v_num; i++)
        for (int j = 1; j <= G.v_num; j++)
            G.adj_matrix[i][j] = 0;
    cout << "请依次输入邻接可达的成对结点：" << endl;
    for (int i = 1; i <= G.arc_num; i++) {
        int v1, v2;
        cin >> v1 >> v2;
        G.adj_matrix[v1][v2] = 1;
    }
}

//创建有向网（带权有向图）
void dir_net_create(graph &G) {
    cout << "请输入要创建的有向网的顶点数和弧数："; cin >> G.v_num >> G.arc_num;
    //结点初始化
    for (int i = 1; i <= G.v_num; i++) G.v[i] = i;//对结点编号
    for (int i = 1; i <= G.v_num; i++)
        for (int j = 1; j <= G.v_num; j++)
            G.adj_matrix[i][j] = inf;
    cout << "请依次输入邻接可达的成对结点及弧长：" << endl;
    for (int i = 1; i <= G.arc_num; i++) {
        int v1, v2,w;
        cin >> v1 >> v2 >> w;
        G.adj_matrix[v1][v2] = w;
    }
}

//创建无向图
void udir_graph_create(graph &G) {
    cout << "请输入要创建的无向图的顶点数和弧数："; cin >> G.v_num >> G.arc_num;
    //结点初始化
    for (int i = 1; i <= G.v_num; i++) G.v[i] = i;//对结点编号
    for (int i = 1; i <= G.v_num; i++)
        for (int j = 1; j <= G.v_num; j++)
            G.adj_matrix[i][j] = 0;
    cout << "请依次输入邻接的成对结点：" << endl;
    for (int i = 1; i <= G.arc_num; i++) {
        int v1, v2;
        cin >> v1 >> v2;
        G.adj_matrix[v1][v2] = 1;
        G.adj_matrix[v2][v1] = 1;
    }
}

//创建无向网（带权无向图）
void udir_net_create(graph &G) {
    cout << "请输入要创建的无向网的顶点数和弧数："; cin >> G.v_num >> G.arc_num;
    //结点初始化
    for (int i = 1; i <= G.v_num; i++) G.v[i] = i;//对结点编号
    for (int i = 1; i <= G.v_num; i++)
        for (int j = 1; j <= G.v_num; j++)
            G.adj_matrix[i][j] = inf;
    cout << "请依次输入邻接的成对结点及弧长：" << endl;
    for (int i = 1; i <= G.arc_num; i++) {
        int v1, v2, w;
        cin >> v1 >> v2 >> w;
        G.adj_matrix[v1][v2] = w;
        G.adj_matrix[v2][v1] = w;
    }
}


void graph_create(graph &G) {
    cout << "************" << endl;
    cout << "0-----有向图" << endl;
    cout << "1-----有向网" << endl;
    cout << "2-----无向图" << endl;
    cout << "3-----无向网" << endl;
    cout << "************" << endl;
    cout << "根据上方菜单，输入相应数字，来创建你想要类型的图" << endl;
    cin >> G.kind;
    switch (G.kind) {
    case 0:dir_graph_create(G); break;
    case 1:dir_net_create(G); break;
    case 2:udir_graph_create(G); break;
    case 3:udir_net_create(G); break;
    default:return;
    }
}

//图深度优先遍历
void dfs1(graph G, int v) {
    if (!vis[v]) {
        cout << G.v[v]<<" ";
        vis[v] = 1;
    }
    for (int i = 1; i <= G.v_num; i++)
        if (!vis[i] && G.adj_matrix[v][i]==1)
            dfs1(G, i);
}

//网深度优先遍历
void dfs2(graph G, int v) {
    if (!vis[v]) {
        cout << G.v[v]<<" ";
        vis[v] = 1;
    }
    for (int i = 1; i <= G.v_num; i++) {
        if (!vis[i] && G.adj_matrix[v][i] != inf)
            dfs2(G, i);
    }
}


//深度优先遍历
void dfs(graph G, int v) {
    init();
    cout << "深度优先遍历结果：";
    switch (G.kind) {
    case 0:
    case 2:dfs1(G, v); break;
    case 1:
    case 3:dfs2(G, v); break;
    default:return;
    }
    cout << endl;
}

//广度优先遍历
void bfs(graph G, int v) {
    init();
    cout << "广度优先遍历结果：";
    queue<int>que;
    if (!vis[v]) {
        cout << G.v[v] << " ";
        vis[v] = 1;
        que.push(v);
    }
    while (!que.empty()) {
        int vertex = que.front();
        que.pop();
        for (int i = 1; i <= G.v_num; i++) {
            if (!vis[i]) {
                if (((G.kind == 0 || G.kind == 2) && G.adj_matrix[vertex][i] == 1) || 
                    ((G.kind==1 || G.kind==3) && G.adj_matrix[vertex][i]!=inf)) {
                    cout << G.v[i] << " ";
                    vis[i] = 1;
                    que.push(i);
                }
            }
        }
    }
    cout << endl;
}

int main() {
    graph G;
    graph_create(G);
    dfs(G, 1);
    bfs(G, 1);
    return 0;
}

/*

下面样例以此图为例
        1-3-4
        |
      6-2-5 
      |___|

下面输入输出样例已去除文字说明
输入样例
2
6 6
1 2
1 3
2 5
2 6
3 4
5 6
输出样例
1 2 5 6 3 4
1 2 3 5 6 4
*/

邻接表建立图并实现图的深度优先遍历和广度优先遍历

/*
    本程序用邻接表实现图的深搜和广搜
    以无向网为例，本例子中的无向网如下（边权重没有写）：
          A-B-C
          |
        F-D-E
        |___|

    //下面是基于上面无向网的输入输出样例（这里权重都简为1）

    请输入要创建的图的结点数和边数：6 6
    ========================================
    结点信息如下
    第1个结点是A
    第2个结点是B
    第3个结点是C
    第4个结点是D
    第5个结点是E
    第6个结点是F
    ========================================
    边信息如下
    请输入第1条边相连的两个结点编号及边的权重：1 2 1
    请输入第2条边相连的两个结点编号及边的权重：1 4 1
    请输入第3条边相连的两个结点编号及边的权重：2 3 1
    请输入第4条边相连的两个结点编号及边的权重：4 5 1
    请输入第5条边相连的两个结点编号及边的权重：4 6 1
    请输入第6条边相连的两个结点编号及边的权重：5 6 1
    邻接表如下：
    A→B→D
    B→A→C
    C→B
    D→A→E→F
    E→D→F
    F→D→E
    从各个结点出发深搜结果：
    A B C D E F
    B A D E F C
    C B A D E F
    D A B C E F
    E D A B C F
    F D A B C E
    从各个结点出发广搜结果：
    A B D C E F
    B A C D E F
    C B A D E F
    D A E F B C
    E D F A B C
    F D E A B C
*/

#include<iostream>
#include<queue>
using namespace std;

const int vertex_max = 100;
typedef char vertex_type;

//边
typedef struct edge_node {
    int vertex;//边所指向的结点编号
    struct edge_node *next;//下一条边
}edge;

//结点
typedef struct vertex_node {
    vertex_type e;//结点名字
    edge *side;
}vertex;

typedef struct Graph {
    vertex adj_list[vertex_max+1];//邻接表
    int w[vertex_max+1][vertex_max + 1];//边权重
    int v_num, e_num;//结点数、边数
}graph;

bool vis[vertex_max + 1];
void init() {
    memset(vis, 0, sizeof(vis));
}

//建立图
void graph_create(graph &G) {
    cout << "请输入要创建的图的结点数和边数：";
    cin >> G.v_num >> G.e_num;
    cout << "========================================" << endl;
    cout << "结点信息如下"<<endl;
    for (int i = 1; i <= G.v_num; i++) {
        cout << "第" << i << "个结点是"; cin >> G.adj_list[i].e;
        G.adj_list[i].side = nullptr;
    }
    cout << "========================================" << endl;
    cout << "边信息如下" << endl;
    for (int i = 1; i <= G.e_num; i++) {
        cout << "请输入第" << i << "条边相连的两个结点编号及边的权重：";
        int x, y,weight;
        cin >> x >> y >> weight;
        G.w[x][y] = G.w[y][x] = weight;
        edge *p_edge = new edge;
        edge *q_edge = new edge;
        p_edge->next = nullptr; p_edge->vertex = y;
        q_edge->next = nullptr; q_edge->vertex = x;
        edge *tmp1 = G.adj_list[x].side;
        edge *tmp2 = G.adj_list[y].side;
        //把x结点指向y结点
        while (tmp1) {
            if (tmp1->next == nullptr) break;
            tmp1 = tmp1->next;
        }
        if (tmp1 == nullptr) G.adj_list[x].side = p_edge;
        else tmp1->next = p_edge;
        //把y结点指向x结点
        while (tmp2) {
            if (tmp2->next == nullptr) break;
            tmp2 = tmp2->next;
        }
        if (tmp2 == nullptr) G.adj_list[y].side = q_edge;
        else tmp2->next = q_edge;
    }
}

//打印邻接表
void adj_list_print(graph G) {
    for (int i = 1; i <= G.v_num; i++) {
        cout << G.adj_list[i].e;
        edge *tmp = G.adj_list[i].side;
        while (tmp) {
            cout <<"→"<< G.adj_list[tmp->vertex].e;
            tmp = tmp->next;
        }
        cout << endl;
    }
}

//深搜（从某结点出发搜索）
void dfs1(graph G, int v) {
    if (!vis[v]) {
        cout << G.adj_list[v].e << " "; vis[v] = true;
    }
    edge *p = G.adj_list[v].side;
    while (p) {
        if (!vis[p->vertex]) dfs1(G, p->vertex);
        p = p->next;
    }
}
//深搜（从各个结点出发搜索）
void dfs(graph G) {
    for (int i = 1; i <= G.v_num; i++) {
        init();
        dfs1(G, i);
        cout << endl;
    }
}

//广搜（从某个结点出发搜索）
void bfs1(graph G,int i) {
        init();
        queue<int>que;
        if (!vis[i]) {
            cout << G.adj_list[i].e << " ";
            que.push(i);
            vis[i] = 1;
        }
        while (!que.empty()) {
            int ii = que.front();
            que.pop();
            edge *p = G.adj_list[ii].side;
            while (p) {
                if (!vis[p->vertex]) {
                    cout << G.adj_list[p->vertex].e << " ";
                    que.push(p->vertex);
                    vis[p->vertex] = 1;
                }
                p = p->next;
            }
        }
}
//广搜（从各个结点出发搜索）
void bfs(graph G) {
    for (int i = 1; i <= G.v_num; i++) {
        bfs1(G, i);
        cout << endl;
    }
}

int main()
{
    graph G;
    graph_create(G);
    cout << "邻接表如下：" << endl; adj_list_print(G);
    cout << "从各个结点出发深搜结果：" << endl; dfs(G);
    cout << "从各个结点出发广搜结果：" << endl; bfs(G);
    return 0;
}
Only you, only you!
关注
  • 5
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
无向图-DFS和BFS
Yxyxb5678的博客
11-04 3127
无向图 1 图 图是由一组顶点和一组能够将两个顶点相连的边组成的。 图（Graph）结构是一种非线性的数据结构，图在实际生活中有很多例子，比如交通运输网，地铁网络，社交网络，计算机中的状态执行等等都可以抽象成图结构。图结构比树结构复杂的非线性结构。 图的构成 **1.顶点（vertex）：**图中的数据元素 **2.边（edge）：**图中连接这些顶点的线 所有的顶点构成一个顶点集合，所有的边构成边的集合，一个完整的图结构就是由顶点集合和边集合组成。图结构在数学上记为以下形式： G=（V,E） 或者 G
用邻接矩阵创建无向图，利用DFS、BFS完成遍历，并在此基础上利用Prim算法生成最小生成树
Laok0413的博客
11-26 1004
1.用邻接矩阵表示无向图更方便，之后在遍历和生成最小生成树时需要不断访问 2.好好理解Prim算法中的lowcost[ ]数组和adjver[ ]数组，虽然adjver[ ] 数组在Prim算法中没什么用 3.Prim的主要思想映射到lowcost[ ]中就是，lowcost[ i ]相当于G.arcs[ i ][ ]，随着不断地迭代，这个i值也会发生改变。当lowcost[ i ] == 0时，就意味着i这个点已经加入到了最小生成树的点集合U中。但是最坑爹的一点就是，前面你把lowcost[
邻接矩阵/图/DFS/BFS
m0_61548909的博客
06-06 2095
目录1.邻接矩阵的表示2.邻接矩阵的存储3.采用邻接矩阵表示法创建无向网 4.基于邻接矩阵的图上各类操作 5.DFS6.BFS7.测试程序（待完成） 权与网连通分量（强连通分量） 无向图 有向图 网（有权图） 3.采用邻接矩阵表示法创建无向网 创建无向图和有向图的区别 优缺点 声明 广度优先搜索需要的队列（图的遍历） 基于邻接矩阵的图上操作 5.DFS 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜
图的表示与基础操作：邻接矩阵与邻接表的C语言实现
最新发布
Mrluo386的博客
05-30 845
图由顶点集和边集构成，边可以是有向或无向的，且可带有权重。根据图的特性选择合适的存储结构至关重要，这直接影响到图的各种操作（如遍历、查找最短路径等）的效率。本文只对于代码做简单分享，不对代码的逻辑做深层解释，如果读者想知道代码的实现逻辑，请详细阅读代码中的注释部分。
数据结构实验：C++实现邻接矩阵创建无向图以及BFS和DFS遍历
qq_45050714的博客
01-02 3044
数据结构实验四：利用邻接矩阵创建无向图，并实现BFS和DFS遍历 1.实验目的 采用邻接矩阵或邻接表进行图的存储 分别完成图的深度优先和宽度优先搜索 2.无向图类 #ifndef graph_h #define graph_h #include<iostream> #include<queue> #include<stack> #include<map> using namespace std; //利用邻接矩阵构造无向图，实现BFS和DFS遍历 clas
邻接矩阵实现无向图的BFS和DFS
何解然_K|user
09-13 1858
一：DFS 创建邻接矩阵图的结构体 typedef struct graph { int vexnum,arcnum;//节点个数，弧的个数 int tyust[MAX][MAX];//使用二维数组定义一个矩阵 char vexs[MAX];//存储节点数据 }*Graph; 创建邻接矩阵图 Graph creat_graph() { int vex,ar...
邻接矩阵，邻接表实现图的创建，遍历(DFS,BFS)
05-12
本文将深入探讨如何使用邻接矩阵和邻接表这两种方法来创建图，并实现深度优先搜索（DFS）和广度优先搜索（BFS）算法。 首先，我们来看邻接矩阵。邻接矩阵是一个二维数组，其中的元素代表图中节点之间的连接状态。...
图的邻接矩阵和邻接表实现
11-26
本文将详细探讨图的两种常见存储方式——邻接矩阵和邻接表，以及基于这两种数据结构的深度搜索（DFS）、广度搜索（BFS）和Dijkstra最短路径算法。 首先，邻接矩阵是一种二维数组，用于表示图中所有节点之间的连接...
tu.zip_tu_邻接矩阵做图_邻接表做图
09-21
在`tu.cpp`这个文件中，很可能是实现了上述的邻接矩阵和邻接表做图的方法，并且包含了BFS和DFS的代码。通过阅读和理解这段代码，你可以进一步了解这两种图的存储方式以及遍历算法的具体实现。 总结起来，邻接矩阵和...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
总之，这个程序设计任务要求我们理解并实现无向图的两种主要遍历方法，以及如何利用邻接表或邻接矩阵存储图。通过这些方法，我们可以有效地探索图的结构，找出路径，解决许多实际问题，如搜索、最短路径计算等。
用邻接矩阵创建无向图，实现DFS+BFS
HXZ_CREATE的博客
06-13 1407
由于图的复杂结构，其物理位置与逻辑位置并不匹配，不能用一维数组来存储图。可考虑用一维数组来存储图的结点信息，二维数组来存储节点间的关系，这种存储方式就叫做邻接矩阵。 图的结点结构定义： typedef struct { char vexs[ MVNum ] ;//存储结点信息 int arcs[ MVNum ][ MVNum ] ; //存储权值 int vexnum , arcnum ;//定义图的节点个数和边的条数 }AMGraph ; 查找结点元素在vexs[]数组中的下标：
无向图DFS+BFS(不全)
m0_51265528的博客
12-11 182
邻接矩阵实现方式 还不完整 #include<iostream> #include<queue> using namespace std; //图的邻接矩阵模式 extern const int maxWeight=9999; const int maxSize = 100; //邻接矩阵存储的图的类定义（无向图） template <class T, class E> class Graphmtx //图的邻接矩阵类定义 { public: Graphmt
C语言数据结构学习笔记(18)-无向网图的DFS和BFS遍历及最小生成树Prim、Kruskal算法
laven_li的博客
11-16 1228
无向网图的DFS和BFS遍历及最小生成树Prim、Kruskal算法
哈工大数据结构实验三：图的邻接表和邻接矩阵DFS与BFS
m0_52972617的博客
12-06 470
#include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h> #define maxlen 100 typedef struct node* Node; struct node{ int n; Node next; }; typedef struct vnode{ int n; Node firstedge; }*Vnode; typedef.
邻接矩阵和邻接表存储的图的基本操作及完整代码
薛定谔的猫的博客
11-14 4065
文章目录构建带权图的邻接矩阵表示 构建带权图的邻接矩阵表示 题目描述： 设有一个带权图G，设计一个算法，输入n个顶点数据和e条边的顶点号i、j及其权值w，构建它的邻接矩阵表示。 实现代码： //顶点值转换为位置（数组下标） int getPos(MGraph G, VertexType v){ int i; for(i=0; i<G.vexnum; i++){ if(G.Vertex[i] == v){ break; }
【图】（一）图的建立 - 邻接矩阵与邻接表 - C语言
友人帐_的博客
10-28 2969
使用C语言的文件操作，以邻接矩阵和邻接表两种方式建立图，并给出两种方式的转换函数。
图的邻接矩阵和邻接表的创建
qq_44143906的博客
12-09 2044
两个结构体存图: struct arcnode{ int data;//存下标i arcnode *next;//单链表下个结点 }; struct lianode{ arcnode *first;//存头结点 }; 初始化邻接链表 lianode a[55]; void inot(){ for(int i=0;i<n;i++){ a[i].first=new arcnode(...
建图方式之“邻接链表” BFS搜索
NotPerfect-EOF
06-15 1520
继续校赛前的建图任务，当时只写了DFS遍历，今天把BFS也写了一下。 #include #include #include #include #include const int maxe = 10001; using namespace std; struct node{ int to,w; node *next; }*head[maxe];//he
用C语言实现使用邻接矩阵或链接表来存储图，并编程实现DFS和BFS算法
05-22
好的，这里给出使用邻接矩阵来存储图，并实现DFS和BFS算法的C语言代码示例。 首先，我们需要定义一个结构体来表示图： ``` #define MAX_VERTEX_NUM 100 // 最大顶点数 typedef struct { int vexs[MAX_VERTEX_NUM...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值