用邻接矩阵创建无向图，实现DFS+BFS

最新推荐文章于 2022-01-02 17:17:05 发布
最新推荐文章于 2022-01-02 17:17:05 发布
阅读量1.3k 收藏 16
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 c语言 算法 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HXZ_CREATE/article/details/106740194
版权

由于图的复杂结构，其物理位置与逻辑位置并不匹配，不能用一维数组来存储图。可考虑用一维数组来存储图的结点信息，二维数组来存储节点间的关系，这种存储方式就叫做邻接矩阵。

图的结点结构定义：

typedef struct
{
    char vexs[ MVNum ] ;//存储结点信息
    int arcs[ MVNum ][ MVNum ] ; //存储权值
    int vexnum , arcnum ;//定义图的节点个数和边的条数
}AMGraph ;

查找结点元素在vexs[]数组中的下标：

int LocateVex( AMGraph G , char ch )
{
    int i ;
    for( i = 0 ; i < G.vexnum ; i++ )
        if( ch == G.vexs[ i ] )
            break ;
    return i ;

}

创建图：

在创建图的过程中，如果结点信息是字符，且用scanf()函数从键盘读取的话，一定要用getchar()将键盘输入后的回车键吸收。这是因为当用户按下回车键时，回车符还在缓冲区内，当下一次调用scanf()时，程序会读取缓冲区内遗留的回车符。关于scanf()的更加详细的解释：C语言scanf函数用法详细解释！

Status CreateUDN( AMGraph *G )
{
    int i , j ;
    printf( "请输入结点个数：" ) ;
    scanf( "%d" , &G->vexnum ) ;
    getchar() ;

    for( i = 0 ; i < G->vexnum ; i++ )
    {
        printf( "请输入第%d个结点的信息：" , i+1 ) ;
        scanf( "%c" , &G->vexs[ i ] ) ;
        getchar() ;
    }

    for( i = 0 ; i < G->vexnum ; i++ )
        for( j = 0 ; j < G->vexnum ; j++ )
            G->arcs[ i ][ j ] = MaxInt ;

    printf( "请输入边的条数：" ) ;
    scanf( "%d" , &G->arcnum ) ;
    getchar() ;

    for( i = 0 ; i < G->arcnum ; i++ )
    {
        int w ;
        char a , b ;
        printf( "请输入两个结点以及两节点间的边的权值：" ) ;
        scanf( "%c %c %d" , &a , &b , &w ) ;
        getchar() ;

        G->arcs[ LocateVex( *G , a ) ][ LocateVex( *G , b ) ] = w ;
        G->arcs[ LocateVex( *G , b ) ][ LocateVex( *G , a ) ] = w ;

    }
    return OK ;
}

邻接矩阵实现DFS算法：

DFS就相当于树的前序遍历。

用visited[]数组来标志结点是否已被遍历过。

void DFS( AMGraph G , int i )
{
    int j ;
    visited[ i ] = TRUE ;
    printf( "%c " , G.vexs[ i ] ) ;

    for( j = 0 ; j < G.vexnum ; j++ )
        if( !visited[ j ] && G.arcs[ i ][ j ] < MaxInt && G.arcs[ i ][ j ] > 0 )
            DFS( G , j ) ;
}

void DFSTraverse( AMGraph G )
{
    int i ;
    for( i = 0 ; i < G.vexnum ; i++ )
        visited[ i ] = FALSE ;

    for( i = 0 ; i < G.arcnum ; i++ ) 
        if( !visited[ i ] )
            DFS( G , i ) ;
}

这里对每个结点都实现DFS可以避免不能遍历非连通图的情况。

邻接矩阵实现BFS算法：

BFS算法需借助于队列来实现，其基本思想是：遍历第一个结点，并将其入队之后，再把它出队，然后把与这个结点相连的所有结点都入队，每遍历一次都进行这样的操作，BFS就相当于树的层序遍历。

void BFSTraverse( AMGraph G )
{
    char temp ;
    int i , j ;
    Queue Q ;
    InitQueue( &Q ) ;
    for( i = 0 ; i < G.vexnum ; i++ )
        visited[ i ] = FALSE ;

    for( i = 0 ; i < G.vexnum ; i++ )
    {
        if( !visited [ i ] )
        {
            visited[ i ] = TRUE ;
            printf( "%c " , G.vexs[ i ] ) ;
            EnQueue( &Q , G.vexs[ i ] ) ;

            while( !EmptyQueue( Q ) )
            {
                DeQueue( &Q , &temp ) ;
                for( j = 0 ; j < G.vexnum ; j++ )//将与刚刚遍历过的结点相连的结点都入队
                {
                    if( G.arcs[ i ][ j ] < MaxInt && G.arcs[ i ][ j ] > 0 && !visited[ j ] )
                    {
                        visited[ j ] = TRUE ;
                        printf( "%c " , G.vexs[ j ] ) ;
                        EnQueue( &Q , G.vexs[ j ] ) ;
                    }
                }
            }
        }
    }
    printf( "\n" ) ;
}

判断队列已满和入队与出队的操作比较简单，这里就不一一列出。

附上源代码：

#include<stdio.h>
#include<stdlib.h>

#define MVNum 100
#define MaxInt 32767
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef char VerTexType ;
typedef int ArcType ;
typedef int Status ;
typedef int Boolean ;

typedef struct
{
    VerTexType vexs[ MVNum ] ;
    ArcType arcs[ MVNum ][ MVNum ] ;
    int vexnum , arcnum ;
}AMGraph ;

typedef struct
{
    char *base ;
    int front ;
    int rear ;
}Queue ;

Boolean visited[ MaxInt ] ;

Status CreateUDN( AMGraph *G ) ;
void DFS( AMGraph G , int i ) ;
void DFSTraverse( AMGraph G ) ;
int LocateVex( AMGraph G , char ch ) ;

void InitQueue( Queue *Q ) ;
int EmptyQueue( Queue Q ) ;
int EnQueue( Queue *Q , char ch ) ;
int DeQueue( Queue *Q , char *ch ) ;
void BFSTraverse( AMGraph G ) ;

int main( void )
{
    AMGraph G ;
    CreateUDN( &G ) ;
    DFSTraverse( G ) ;
    BFSTraverse( G ) ;
    return 0 ;
}

int LocateVex( AMGraph G , char ch )
{
    int i ;
    for( i = 0 ; i < G.vexnum ; i++ )
        if( ch == G.vexs[ i ] )
            break ;
    return i ;

}

Status CreateUDN( AMGraph *G )
{
    int i , j ;
    printf( "请输入结点个数：" ) ;
    scanf( "%d" , &G->vexnum ) ;
    getchar() ;

    for( i = 0 ; i < G->vexnum ; i++ )
    {
        printf( "请输入第%d个结点的信息：" , i+1 ) ;
        scanf( "%c" , &G->vexs[ i ] ) ;
        getchar() ;
    }

    for( i = 0 ; i < G->vexnum ; i++ )
        for( j = 0 ; j < G->vexnum ; j++ )
            G->arcs[ i ][ j ] = MaxInt ;

    printf( "请输入边的条数：" ) ;
    scanf( "%d" , &G->arcnum ) ;
    getchar() ;

    for( i = 0 ; i < G->arcnum ; i++ )
    {
        int w ;
        char a , b ;
        printf( "请输入两个结点以及两节点间的边的权值：" ) ;
        scanf( "%c %c %d" , &a , &b , &w ) ;
        getchar() ;

        G->arcs[ LocateVex( *G , a ) ][ LocateVex( *G , b ) ] = w ;
        G->arcs[ LocateVex( *G , b ) ][ LocateVex( *G , a ) ] = w ;

    }
    return OK ;
}

void DFS( AMGraph G , int i )
{
    int j ;
    visited[ i ] = TRUE ;
    printf( "%c " , G.vexs[ i ] ) ;

    for( j = 0 ; j < G.vexnum ; j++ )
        if( !visited[ j ] && G.arcs[ i ][ j ] < MaxInt && G.arcs[ i ][ j ] > 0 )
            DFS( G , j ) ;
}

void DFSTraverse( AMGraph G )
{
    int i ;
    for( i = 0 ; i < G.vexnum ; i++ )
        visited[ i ] = FALSE ;

    for( i = 0 ; i < G.arcnum ; i++ )
        if( !visited[ i ] )
            DFS( G , i ) ;

    printf( "\n" ) ;
}

void InitQueue( Queue *Q )
{
    Q->base = ( char * )malloc( sizeof( char ) * MaxInt ) ;
    Q->front = Q->rear = 0 ;
}

int EmptyQueue( Queue Q )
{
    if( Q.front == Q.rear )
        return TRUE ;
    else
        return FALSE ;
}

int EnQueue( Queue *Q , char ch )
{
    if( ( Q->rear + 1 ) % MaxInt == Q->front )
        return ERROR ;
    else
    {
        Q->base[ Q->rear ] = ch ;
        Q->rear = ( Q->rear +1 ) % MaxInt ;
    }
        return OK ;
}

int DeQueue( Queue *Q , char *ch )
{
    if( EmptyQueue( *Q ) )
        return ERROR ;
    else
    {
        *ch = Q->base[ Q->front ] ;
        Q->front = ( Q->front + 1 ) % MaxInt ;
    }
        return OK ;
}

void BFSTraverse( AMGraph G )
{
    char temp ;
    int i , j ;
    Queue Q ;
    InitQueue( &Q ) ;
    for( i = 0 ; i < G.vexnum ; i++ )
        visited[ i ] = FALSE ;

    for( i = 0 ; i < G.vexnum ; i++ )
    {
        if( !visited [ i ] )
        {
            visited[ i ] = TRUE ;
            printf( "%c " , G.vexs[ i ] ) ;
            EnQueue( &Q , G.vexs[ i ] ) ;

            while( !EmptyQueue( Q ) )
            {
                DeQueue( &Q , &temp ) ;
                for( j = 0 ; j < G.vexnum ; j++ )
                {
                    if( G.arcs[ i ][ j ] < MaxInt && G.arcs[ i ][ j ] > 0 && !visited[ j ] )
                    {
                        visited[ j ] = TRUE ;
                        printf( "%c " , G.vexs[ j ] ) ;
                        EnQueue( &Q , G.vexs[ j ] ) ;
                    }
                }
            }
        }
    }
    printf( "\n" ) ;
}
h3xz
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无向图遍历
01-23
无向图的存储方式有邻接矩阵，邻接链表，稀疏矩阵等。 无向图主要包括双方面内容，图的遍历和寻找联通分量。 无向图的遍历 无向图的遍历有两种方式—广度优先搜索(BFS)和深度优先搜索(DFS)。广度优先搜索在遍历一...
邻接矩阵/图/DFS/BFS
m0_61548909的博客
06-06 1905
目录1.邻接矩阵的表示2.邻接矩阵的存储3.采用邻接矩阵表示法创建无向网 4.基于邻接矩阵的图上各类操作 5.DFS6.BFS7.测试程序（待完成） 权与网连通分量（强连通分量） 无向图 有向图 网（有权图） 3.采用邻接矩阵表示法创建无向网 创建无向图和有向图的区别 优缺点 声明 广度优先搜索需要的队列（图的遍历） 基于邻接矩阵的图上操作 5.DFS 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜
数据结构：无向图邻接表、邻接矩阵创建及其BFS、DFS遍历(C语言)
weixin_55797565的博客
12-05 4052
实验目的： 1．掌握图的定义和构造方法； 2．掌握图的存储及遍历方法及应用。 实验内容： 编程实现： 1、建立一个以邻接表形式存储的图； 2、建立一个以邻接矩阵形式存储的图； 3、以邻接表形式存储的图的深度优先遍历； 4、以邻接表形式存储的图的广度优先遍历； 5、以邻接矩阵形式存储的图的深度优先遍历； 6、以邻接矩阵形式存储的图的广度优先遍历； 学习邻接表时候画的图，如果没有动态视频教程的话，个人觉得看着代码一层一层画图很容易理解 个人比较懒，下面是代码：（注释应该能看懂吧哈哈哈
基于邻接矩阵和邻接表的两种方法实现无向图的BFS和DFS
lxpaopao的专栏
04-01 6525
广度优先搜索(Breadth-First-Search)和深度优先搜索(Deep－First－Search)是搜索策略中最经常用到的两种方法,特别常用于图的搜索. BFS的思想：       从一个图的某一个顶点V0出发，首先访问和V0相邻的且未被访问过的顶点V1、V2、……Vn，然后依次访问与V1、V2……Vn相邻且未被访问的顶点。如此继续，找到所要找的顶点或者遍历完整个图。我们采用
图的BFS与DFS算法在邻接矩阵与邻接表存储结构下实现
weixin_46127065的博客
10-19 2957
如题 自用笔记 如有错误欢迎及时指正
无向图的遍历-BFS与DFS
m0_56695695的博客
11-29 3310
一，理论部分 无向图的遍历可用深度搜索（BFS）与广度搜索（DFS） 深度搜索的基本方式是由图的一个节点1出发然后随机选一个与其相邻的节点2，接着在选择一个与其相邻的节点3，当一条路遍历完后再选择未遍历的一个节点重复上述操作，直至将图的点遍历完。 广度搜索的基本方式是由图的一个节点出发，然后遍历所有与其相邻的节点，接着再遍历与相邻节点相邻的节点，重复上述步骤，直至将图上的节点遍历完 遍历的关键是如何判断节点是否已经遍历过，可以定义一个辅助结构体进行判断，结构体里储存的是节点和与之相关的系数flag，
实现图的主要操作
05-08
与图相关的操作，采用邻接矩阵或邻接表作为存储结构，完成有向图和无向图的DFS和BFS操作
C++ 数据结构 邻接矩阵
12-11
设计一个有向图和一个无向图，使用邻接矩阵和邻接表存储结构，完成在这两种存储结构下有向图和无向图的DFS（深度优先遍历）和BFS（广度优先遍历）的操作。 三、实验要求： 1. 根据实验内容编程，画出你所设计的图，...
数据结构无向图
06-04
邻接矩阵存储，实现dfs、bfs
头歌数据结构图的邻接表存储及遍历操作
05-26
头歌数据结构图的邻接表存储及遍历操作 第1关图的邻接表存储及求邻接点操作 第2关图的深度遍历 第3关图的广度遍历 稳过
图的DFS和BFS遍历算法（采用邻接矩阵的存储结构创建无向图G）
qq_54467680的博客
12-15 511
#include<iostream> using namespace std; #define MaxInt 0 #define MVNum 8 //顶点的个数 typedef char VerTexType; //顶点的数据类型 typedef int ArcType; //边的权值的数据类型 typedef struct { VerTexType vexs[MVNum]; //顶点表 ArcType arcs[MVNum][MVNum]; //...
用邻接矩阵创建无向图，利用DFS、BFS完成遍历，并在此基础上利用Prim算法生成最小生成树
Laok0413的博客
11-26 957
1.用邻接矩阵表示无向图更方便，之后在遍历和生成最小生成树时需要不断访问 2.好好理解Prim算法中的lowcost[ ]数组和adjver[ ]数组，虽然adjver[ ] 数组在Prim算法中没什么用 3.Prim的主要思想映射到lowcost[ ]中就是，lowcost[ i ]相当于G.arcs[ i ][ ]，随着不断地迭代，这个i值也会发生改变。当lowcost[ i ] == 0时，就意味着i这个点已经加入到了最小生成树的点集合U中。但是最坑爹的一点就是，前面你把lowcost[
无向图-DFS和BFS
Yxyxb5678的博客
11-04 3043
无向图 1 图 图是由一组顶点和一组能够将两个顶点相连的边组成的。 图（Graph）结构是一种非线性的数据结构，图在实际生活中有很多例子，比如交通运输网，地铁网络，社交网络，计算机中的状态执行等等都可以抽象成图结构。图结构比树结构复杂的非线性结构。 图的构成 **1.顶点（vertex）：**图中的数据元素 **2.边（edge）：**图中连接这些顶点的线 所有的顶点构成一个顶点集合，所有的边构成边的集合，一个完整的图结构就是由顶点集合和边集合组成。图结构在数学上记为以下形式： G=（V,E） 或者 G
数据结构实验：C++实现邻接矩阵创建无向图以及BFS和DFS遍历
qq_45050714的博客
01-02 2872
数据结构实验四：利用邻接矩阵创建无向图，并实现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 1811
一：DFS 创建邻接矩阵图的结构体 typedef struct graph { int vexnum,arcnum;//节点个数，弧的个数 int tyust[MAX][MAX];//使用二维数组定义一个矩阵 char vexs[MAX];//存储节点数据 }*Graph; 创建邻接矩阵图 Graph creat_graph() { int vex,ar...
(编程训练)再回首，数据结构——无向图的邻接矩阵表示、DFS、BFS
my_adu的专栏
05-28 1877
最近在复习数据结构，顺便看看大一的时候写的代码，看完之后比当初有了更加深刻的体会。        希望这些能提供给初学者一些参考。         在VC++6.0下可运行，当初还写了不少注释。   【问题描述】 建立图的邻接矩阵存储结构，实现图的遍历 【基本要求】 ·功能：建立图的邻接矩阵存储结构，实现图的BFS、DFS ·输入：输入连通图的顶点数、顶点信息、边数、顶点对序
无向图DFS+BFS(不全)
m0_51265528的博客
12-11 176
邻接矩阵实现方式 还不完整 #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 1212
无向网图的DFS和BFS遍历及最小生成树Prim、Kruskal算法
网状结构（图）图的存储（邻接矩阵、邻接表）、图的遍历（深度DFS、广度BFS）、图的最短路径
巫山♔
05-21 2816
图 多对多关系 是一种网状数据结构，图是由非空的顶点集合和一个描述顶点之间关系的集合组成 其定义 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为弧尾或起始点，称
利用邻接矩阵创建无向图实现DFS和BFS
最新发布
05-04
好的，下面是利用邻接矩阵创建无向图实现DFS和BFS的 Python 代码： ```python class Graph: def __init__(self, vertices): self.V = vertices self.adj_matrix = [[0] * self.V for _ in range(self.V)] def ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值