数据结构 - 图的存储结构表示及其遍历 （DFS && BFS）

最新推荐文章于 2024-03-11 17:14:17 发布
最新推荐文章于 2024-03-11 17:14:17 发布
阅读量1.6k 收藏
点赞数 1
分类专栏： 数据结构 文章标签： acm c++ 数据结构 图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014355480/article/details/41881687
版权



1、邻接矩阵表示的图结构

/* 邻接矩阵表示的图结构 */
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
using namespace std;

 
typedef char VertexType;                //顶点类型应由用户定义
typedef int EdgeType;                   //边上的权值类型应由用户定义
 
#define MAXVEX  100             //最大顶点数，应由用户定义
#define INF   0               //用0来代表不存在该边 
#define DEBUG
 
typedef struct
{
    VertexType vexs[MAXVEX];            //顶点表
    EdgeType   arc[MAXVEX][MAXVEX];         //邻接矩阵，可看作边
    int numVertexes, numEdges;      //图中当前的顶点数和边数
}Graph;
 
//定位
int locates(Graph *g, char ch)
{
    int i = 0;
    for(i = 0; i < g->numVertexes; i++)
    {
        if(g->vexs[i] == ch)
        {
            return i;
        }
    }
    if(i >= g->numVertexes)
    {
        return -1;
    }
}
 
//建立一个无向网图的邻接矩阵表示
void CreateGraph(Graph *g)
{
    int i, j, k, w;
    printf("输入顶点数和边数:\n");
    scanf("%d %d", &(g->numVertexes), &(g->numEdges));
     
    #ifdef DEBUG
    printf("%d %d\n", g->numVertexes, g->numEdges);
    #endif

	printf("输入顶点：\n");
    for(i = 0; i < g->numVertexes; i++)
    {
        g->vexs[i] = getchar();
        while(g->vexs[i] == '\n')
        {
            g->vexs[i] = getchar();
        }
    }
     
    #ifdef DEBUG
    for(i = 0; i < g->numVertexes; i++)
    {
        printf("%c ", g->vexs[i]);
    }
    printf("\n");
    #endif
 
 
    for(i = 0; i < g->numVertexes; i++)
    {
        for(j = 0; j < g->numVertexes; j++)
        {
            g->arc[i][j] = INF; //邻接矩阵初始化
        }
    }
    for(k = 0; k < g->numEdges; k++)
    {
        char p, q;
        printf("输入边(vi,vj)上的下标i，下标j和权值:\n");
         
        p = getchar();
        while(p == '\n')
        {
            p = getchar();
        }
        q = getchar();
        while(q == '\n')
        {
            q = getchar();
        }
        scanf("%d", &w);    
         
        int m = -1;
        int n = -1;
        m = locates(g, p);
        n = locates(g, q);
        if(n == -1 || m == -1)
        {
            fprintf(stderr, "there is no this vertex.\n");
            return;
        }
        //getchar();
        g->arc[m][n] = w;
        g->arc[n][m] = g->arc[m][n];  //因为是无向图，矩阵对称
    }
}
 
//打印图
void printGraph(Graph g)
{
    int i, j;
    for(i = 0; i < g.numVertexes; i++)
    {
        for(j = 0; j < g.numVertexes; j++)
        {
            printf("%6d ", g.arc[i][j]);
        }
        printf("\n");
    }
}
 
#define MAXVEX  100     //最大顶点数
bool visited[MAXVEX];        //访问标志数组
#define TRUE 1
#define FALSE 0
 
//邻接矩阵的深度优先递归算法
void DFS(Graph g, int i)
{
    int j;
    visited[i] = TRUE;
    printf("%c ", g.vexs[i]);                           //打印顶点，也可以其他操作
    for(j = 0; j < g.numVertexes; j++)
    {
        if(g.arc[i][j]!=0 && !visited[j])
        {
            DFS(g, j);                  //对为访问的邻接顶点递归调用
        }
    }
}
 
//邻接矩阵的深度遍历操作
void DFSTraverse(Graph g)
{
    int i;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;         //初始化所有顶点状态都是未访问过状态
    }
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])             //对未访问的顶点调用DFS，若是连通图，只会执行一次
        {
            DFS(g,i);
        }
    }
    printf("\n");
}
 
//邻接矩阵的广度遍历算法
void BFSTraverse(Graph g)
{
    int i, j;
    queue<int> q;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    for(i = 0; i < g.numVertexes; i++)//对每个顶点做循环
    {
        if(!visited[i])               //若是未访问过
        {
            visited[i] = TRUE;
            printf("%c ", g.vexs[i]); //打印结点，也可以其他操作
            q.push(i);          //将此结点入队列
            while(!q.empty())     
            {
                int m = q.front();
                q.pop();        
                for(j = 0; j < g.numVertexes; j++)
                {
                    //判断其他顶点若与当前顶点存在边且未访问过
                    if(g.arc[m][j] != 0 && !visited[j])
                    {
                        visited[j] = TRUE;
                        printf("%c ", g.vexs[j]);
                        q.push(j);
                    }
                }
            }
        }
    }
    printf("\n");
}


int main(int argc, char **argv)
{
    Graph g;
     
    //邻接矩阵创建图
    CreateGraph(&g);
    printGraph(g);
    DFSTraverse(g);
    BFSTraverse(g);
    
    return 0;
}



2、邻接表表示的图结构

/* 邻接表表示的图结构 */
#include <cstdio>
#include <cstdlib>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
using namespace std;


#define MAXVEX  100     //最大顶点数
bool visited[MAXVEX];        //访问标志数组
#define TRUE 1
#define FALSE 0

#define DEBUG
#define MAXVEX 1000         //最大顶点数
typedef char VertexType;        //顶点类型应由用户定义
typedef int EdgeType;           //边上的权值类型应由用户定义

typedef struct EdgeNode         //边表结点
{
    int adjvex;         //邻接点域，存储该顶点对应的下标
    EdgeType weigth;        //用于存储权值，对于非网图可以不需要
    struct EdgeNode *next;      //链域，指向下一个邻接点
}EdgeNode;
 
typedef struct VertexNode       //顶点表结构
{
    VertexType data;        //顶点域，存储顶点信息
    EdgeNode *firstedge;        //边表头指针
}VertexNode, AdjList[MAXVEX];
 
typedef struct
{
    AdjList adjList;
    int numVertexes, numEdges;  //图中当前顶点数和边数
}GraphList;
 
int Locate(GraphList *g, char ch)
{
    int i;
    for(i = 0; i < MAXVEX; i++)
    {
        if(ch == g->adjList[i].data)
        {
            break;
        }
    }
    if(i >= MAXVEX)
    {
        fprintf(stderr,"there is no vertex.\n");
        return -1;
    }
    return i;
}
 
//建立图的邻接表结构
void CreateGraph(GraphList *g)
{
    int i, j, k;
    EdgeNode *e;
    EdgeNode *f;
    printf("输入顶点数和边数:\n");
    scanf("%d %d", &g->numVertexes, &g->numEdges);
     
    #ifdef DEBUG
    printf("%d %d\n", g->numVertexes, g->numEdges);
    #endif
     
    for(i = 0; i < g->numVertexes; i++)
    {
        printf("请输入顶点%d:\n", i);
        g->adjList[i].data = getchar();          //输入顶点信息
        g->adjList[i].firstedge = NULL;          //将边表置为空表
        while(g->adjList[i].data == '\n')
        {
            g->adjList[i].data = getchar();
        }
    }
    //建立边表
    for(k = 0; k < g->numEdges; k++)
    {
        printf("输入边(vi,vj)上的顶点序号:\n");
        char p, q;
        p = getchar();
        while(p == '\n')
        {
            p = getchar();
        }
        q = getchar();
        while(q == '\n')
        {
            q = getchar();
        }
        int m, n;
        m = Locate(g, p);
        n = Locate(g, q);
        if(m == -1 || n == -1)
        {
            return;
        }
        #ifdef DEBUG
        printf("p = %c\n", p);
        printf("q = %c\n", q);
        printf("m = %d\n", m);
        printf("n = %d\n", n);
        #endif
     
        //向内存申请空间，生成边表结点
        e = (EdgeNode *)malloc(sizeof(EdgeNode));
        if(e == NULL)
        {
            fprintf(stderr, "malloc() error.\n");
            return;
        }
        //邻接序号为j
        e->adjvex = n;
        //将e指针指向当前顶点指向的结构
        e->next = g->adjList[m].firstedge;
        //将当前顶点的指针指向e
        g->adjList[m].firstedge = e;
         
        f = (EdgeNode *)malloc(sizeof(EdgeNode));
        if(f == NULL)
        {
            fprintf(stderr, "malloc() error.\n");
            return;
        }
        f->adjvex = m;
        f->next = g->adjList[n].firstedge;
        g->adjList[n].firstedge = f;
    }
}
 
 
void printGraph(GraphList *g)
{
    int i = 0;
    #ifdef DEBUG
    printf("printGraph() start.\n");
    #endif
     
    while(g->adjList[i].firstedge != NULL && i < MAXVEX)
    {
        printf("顶点:%c  ", g->adjList[i].data);
        EdgeNode *e = NULL;
        e = g->adjList[i].firstedge;
        while(e != NULL)
        {
            printf("%d  ", e->adjvex);
            e = e->next;
        }
        i++;
        printf("\n");
    }
}
 
//邻接表的深度递归算法
void DFS(GraphList g, int i)
{
    EdgeNode *p;
    visited[i] = TRUE;
    printf("%c ", g.adjList[i].data);   //打印顶点，也可以其他操作
    p = g.adjList[i].firstedge;
    while(p)
    {
        if(!visited[p->adjvex])
        {
            DFS(g, p->adjvex);           //对访问的邻接顶点递归调用
        }
        p = p->next;
    }
}
 
//邻接表的深度遍历操作
void DFSTraverse(GraphList g)
{
    int i;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])
        {
            DFS(g, i);
        }
    }
    printf("\n");
} 
 
//邻接表的广度遍历算法
void BFSTraverse(GraphList g)
{
    int i;
    EdgeNode *p;
    queue<int> q;
    for(i = 0; i < g.numVertexes; i++)
    {
        visited[i] = FALSE;
    }
    for(i = 0; i < g.numVertexes; i++)
    {
        if(!visited[i])
        {
            visited[i] = TRUE;
            printf("%c ", g.adjList[i].data);   //打印顶点，也可以其他操作
            q.push(i);
            while(!q.empty())
            {
                int m;
                m = q.front();
                q.pop();
                p = g.adjList[m].firstedge;    // 找到当前顶点边表链表头指针
                while(p)
                {
                    if(!visited[p->adjvex])
                    {
                        visited[p->adjvex] = TRUE;
                        printf("%c ", g.adjList[p->adjvex].data);
                    	q.push(p->adjvex);
                    }
                    p = p->next;
                }
            }
        }
    }
    printf("\n");
} 
 
 
 
int main(int argc, char **argv)
{
    GraphList g;
    CreateGraph(&g);
    printGraph(&g);
    
    DFSTraverse(g);
    BFSTraverse(g);
    
    return 0;
}


zzuspy
关注
专栏目录
数据结构实验---图的储存与遍历.doc
10-10
在实验"数据结构实验---图的储存与遍历.doc"中，主要探讨了图的两种常见存储方法——邻接矩阵和邻接表，以及如何在这两种存储方式下实现深度优先遍历(DFS)和广度优先遍历(BFS)。 邻接矩阵是表示图的一种直观方法，...
datawhale图神经网络 task1 图数据结构 PyG环境配置
weixin_46121449的博客
06-14 442
一、图的表示 定义一（图）： 一个图被记为G={V,E}\mathcal{G}=\{\mathcal{V}, \mathcal{E}\}G={V,E}，其中 V={v1,…,vN}\mathcal{V}=\left\{v_{1}, \ldots, v_{N}\right\}V={v1​,…,vN​}是数量为N=∣V∣N=|\mathcal{V}|N=∣V∣ 的结点的集合， E={e1,…,eM}\mathcal{E}=\left\{e_{1}, \ldots, e_{M}\right\}E={e1​,…,
数据结构：图的存储与遍历
最新发布
m0_63997099的博客
03-11 611
绿色容易忘，黄色是笔记，蓝色是提高
图的存储 与 DFS BFS遍历
Qisi_Li的博客
05-10 224
图的储存结构 1.邻接矩阵 P179 未完待续 2.邻接表 P181 typedef struct node//表结点 { int adivex;//邻接域点 struct node *next;//指向下一个邻接点的指针域 //若要表示边上的信息，则要添加一个数据域 info }EdgeNode ; typedef struct vnode //表头结点 { VertexType vertex; //顶点域 EdgeNode * firstedge; //表头指针 }Ve
数据结构 --- 图的遍历 DFS、BFS
weixin_60569662的博客
04-03 3717
什么是DFS、BFS？ 一条线走到底，深度优先遍历，每一个顶点只遍历、只打印一次的方式：DFS、BFS 数据结构 --- 图的存储_考拉爱睡觉鸭~的博客-CSDN博客 单纯地把邻接顶点的邻接顶点打印出来，顶点重复遍历，打印多次 从 A→F 所有的节点都遍历完了，需要做回退，从F回退到D点，找D点有没有邻接顶点，没有邻接顶点，继续做回退，退到B节点，有未访问的临接顶点，访问C顶点 如果遍历的节点已经被遍历了，不能重复遍历，要做回退 如果形成环状，也是重复遍历的情况，也要做回.........
数据结构-图
weixin_42066314的博客
06-29 3956
​一、概念 说到图，大多数人立刻会想到一幅画，一张地图……但是我们今天所说的图是一种数据结构。 图是由顶点（vertice）集和边（edge）集组成的，图又分为有向图、无向图、带权图，下图所示的是一个有向图 有向图：顾名思义就是具有方向的图，如上所示，顶点1指向顶点2，但是顶点2无法指向顶点1。 无向图：就是不区分方向的图，顶点1可以指向顶点2,同时顶点2也可以指向顶点1。 带权图：表示边带有权重的图，如下图所示 另外图中还包含路径这个概念，如上图v1到v7的路径有 v1->
数据结构-DFS and BFS-PPT
02-04
"数据结构-DFS和BFS-PPT" 数据结构是计算机科学中的一种基本概念，它是指数据在计算机中的组织和存储方式。DFS（Depth-First Search，深度优先搜索）和BFS（Breadth-First Search，广度优先搜索）是两种常用的图...
数据结构--图的遍历及应用--思维导图.pdf
08-29
"数据结构--图的遍历及应用" 图的遍历是数据结构中的一种重要算法，指的是从图中某一顶点出发，按照某种搜索方法沿着图中的边对图中的所有顶点访问一次且仅访问一次。图的遍历可以分为两大类：广度优先遍历（BFS）...
头歌数据结构图的邻接表存储及遍历操作
05-26
### 二、头歌数据结构图的邻接表存储 #### 1. 数据类型定义 - **顶点类型**：`VertexType` 定义为一个字符数组，用于存储顶点的名称。 - **图的种类**：`GraphKind` 定义了四种类型的图：有向图 (DG)、有向网 (DN)...
数据结构图bfs，Dfs遍历算法
12-09
总结起来，数据结构中的图遍历算法，尤其是DFS和BFS，是理解和操作图形数据的基础。它们在实际编程问题中，如网络爬虫、社交网络分析、图形渲染等领域都有广泛应用。通过深入学习和实践这些算法，可以提升解决复杂...
邻接表存储的图的DFS，BFS遍历
04-06
邻接表存储的图的DFS，BFS遍历。文档描述： http://blog.csdn.net/qq_16912257/article/details/45848935
图的dfs和bfs遍历-c语言版
06-11
c语言版数据结构中的图的bfs和dfs遍历
图的存储与遍历(数据结构)
12-10
目 录 第一章 课程设计目的 2 第二章 课程设计内容和要求 2 第三章 课程设计分析 3 第四章 算法描述 4 第五章 源代码 8 第六章 运行结果分析 13 第七章 结束语 15 第八章 参考文献 15 第一章 课程设计目的 本学期我们对《数据结构》这门课程进行了学习。这门课程是一门实践性非常强的课程，为了让大家更好地理解与运用所学知识，提高动手能力，我们进行了此次课程设计实习。这次课程设计不但要求实习者掌握《数据结构》中的各方面知识，还要求实习者具备一定的C语言基础和编程能力。 具体说来，这次课程设计主要有两大方面目的。 一是让实习者通过实习掌握《数据结构》中的知识。对于《图的存储与遍历》这一课题来说，所要求掌握的数据结构知识主要有：图的邻接表存贮结构、队列的基本运算实现、邻接表的算法实现、图的广度优先搜索周游算法实现、图的深度优先搜索周游算法实现。 二是通过实习巩固并提高实习者的C语言知识，并初步了解Visual C++的知识，提高其编程能力与专业水平。 第二章 课程设计内容和要求 2.1课程设计内容 该课题要求以邻接表的方式存储图，输出邻接表，并要求实现图的深度、广度两种遍历。
图的存储结构和遍历
12-17
//----------------------图的邻接矩阵存储表示----------------------- typedef struct ArcCell { VRType adj; //顶点关系类型。对无权图，用1或0表示是否相邻 }ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; typedef struct { VertexType vexs[MAX_VERTEX_NUM]; //顶点向量 AdjMatrix arcs; //邻接矩阵 int vexnum,arcnum; //图的当前顶点数和弧数 }MGraph; //-----------------------图的邻接表存储表示------------------------ typedef struct ArcNode { int adjvex; //该弧所指向的顶点的位置 struct ArcNode *nextarc; //指向下一条弧的指针 InfoType *info; //该弧相关信息的指针值 }ArcNode; typedef struct VNode { VertexType data; //顶点信息 ArcNode *firstarc; //指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VERTEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; //图的当前顶点数和弧数 }ALGraph;
数据结构(17)--图的遍历DFS和BFS
小白的专栏
03-04 9682
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次。这一过程就叫做图的遍历。 示例: 1.深度优先遍历 基本思想： 从图中某顶点V0出发，访问此顶点，然后依次从V0的各个未被访问的...
数据结构 图的邻接表存储结构及DFS/BFS遍历
Logan
12-16 849
//邻接表 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; #define INF 999 using namespace std; typedef struct ArcNode { int adjvex; struct ArcNode...
数据结构之 图的操作
weixin_30517001的博客
10-01 891
一、图的存储结构 1.1 邻接矩阵 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 看一个实例，下图左就是一个无向图。 从上面可以看...
数据结构--图的遍历（DFS和BFS）
HWQlet的博客
01-26 701
博前感想： 图的遍历创建的思想比较容易懂，深度遍历和广度遍历需要自己动动脑筋。深度遍历是基于栈的思想--先进后出，广度遍历是基于队列的思想--先进先出。 代码块： #include&lt;string&gt; #include&lt;iostream&gt; #include&lt;cmath&gt; #include&lt;stack&gt; #include&lt;queue&gt; ...
【数据结构与算法】自己动手实现图的BFS和DFS（附完整源码）
热门推荐
兰亭风雨的专栏
02-22 2万+
本文的重点在于图的深度优先搜索（DFS）和广度优先搜索（BFS），因此不再对图的基本概念做过多的介绍，但是要先大致了解下图的几种常见的存储结构。 邻接矩阵既可以用来存储无向图，也可以用来存储有向图。该结构实际上就是用一个二维数组（邻接矩阵）来存储顶点的信息和顶点之间的关系（有向图的弧或无向图的边）。 邻接表是图的一种链式存储结构，既适合于存储无向图，也适合于存储有向图。在邻接表中，用一个一维数组存储图中的每个顶点的信息，同时为每个顶点建立一个单链表，链表中的节点保存依附在该顶点上的边或弧的信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值