数据结构（六）——图

于 2023-08-14 22:15:44 发布
阅读量152 收藏
点赞数
分类专栏： 嵌入式学习 数据结构 文章标签： 数据结构 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59566583/article/details/132286497
版权

一、定义

图是一种常用的数据结构，用于表示多个对象之间的关系。图由节点（也称为顶点）和边组成。节点表示
对象，而边表示节点之间的关系。

图可以分为有向图和无向图。有向图中的边有方向，例如从节点A到节点B的边表示A指
向B。无向图中的边没有方向，可以双向连接两个节点。

图可以用多种方式表示。最常见的表示方法是邻接矩阵和邻接表。

邻接矩阵是一个二维数组，其中行和列表示节点，而数组中的元素表示节点之间的连接关系。如果节点i
和节点j之间有边，则矩阵的第i行第j列元素为1，否则为0。

邻接表是由节点的链表组成的数组。每个节点都有一个链表，其中存储了该节点的邻居节点。

图可以用于解决各种问题，比如路线规划、社交网络分析、最短路径算法等。常见的图算法有深度优先
搜索（DFS）和广度优先搜索（BFS），用于遍历图中的节点。

二、代码示例（邻接矩阵表示）


1.头文件


/*===============================================
*   文件名称：seqG.h
*   创 建 者: 
*   创建日期：2023年08月13日
*   描    述：
================================================*/
#ifndef _SEQG_H
#define _SEQG_H

#define N 1024

typedef char seqG_data ;

typedef struct seq_G
{

    seqG_data data[N] ;//节点数据存储数组
    int  data_n ; //节点个数
    int  data_v ; //边数
    int  edge_data[N][N];// 边的关系

    int flag[N] ; //访问记录
}seqG , *pseqG;

//创建图
pseqG init_seqG();

//图展示
int show_seqG( pseqG G );

//广度遍历BFS
int BFS_seqG( pseqG G );

//深度遍历DFS(递归)
int DDFS_seqG( pseqG G , int V);

//深度遍历DFS
int DFS_seqG( pseqG G );

#endif

2.功能代码


创建图

//创建图
pseqG init_seqG()
{
    pseqG G = (pseqG) malloc(sizeof(seqG));
    if( NULL == G )
    {
        return NULL ;
    }
    
    memset(G->flag,0,sizeof(G->flag));

    //获取顶点个数
    puts("输入顶点个数：");
    scanf("%d",&(G->data_n));
    getchar();

    //获取顶点
    puts("请输入顶点：");
    for(int i = 0 ; i < G->data_n ; i++ )
    {
        seqG_data i_data ;
        scanf("%c",&i_data);
        G->data[i] = i_data;
    }
    getchar();
    
    memset(G->edge_data,0,sizeof(G->edge_data));//初值为0

    //获取边的关系;
    puts("边的关系:");
    for(int i = 0 ; i < G->data_n ; i++ )
    {
        for(int j = 0 ; j < G->data_n ; j++ )
        {
            printf("%c——%c:",G->data[i],G->data[j]);
            scanf("%d",&G->edge_data[i][j]);

        }
    }
        getchar();

    return G ;
}

图展示（邻接矩阵）

//图展示
int show_seqG( pseqG G )
{
    if( NULL == G )
    {
        return -1;
    }
    

    puts("矩阵：");
    for( int i = 0 ; i <G->data_n ; i++ )
    {
        for( int j = 0 ; j < G->data_n ; j++ )
        {
            printf("%4d",G->edge_data[i][j]);
        }
        puts("");
    }

    return 0;
}

广度遍历

通过队列实现广度遍历

//广度遍历BFS
int BFS_seqG( pseqG G )
{
    if( NULL == G )
    {
        return -1;
    }
    
    //将G中的flag数组置0
    memset(G->flag,0,sizeof(G->flag));

    //创建一个队列
    psqueue Q =  init_seqqueue();
    if( 0 == Q )
    {
        return -1;
    }

    //将图G的一个开始节点的下标入队
    if( 0 != input_seqqueue(Q,0))
    {
        printf("input queue err\n");
        return -1;
    }

    while( 0 != empty_seqqueue(Q)) //队列不为空时一直循环
    {
        int index = out_seqqueue(Q); //队列出队，记录出队元素为index

        if( G->flag[index] == 0 ) //如果该下标未被访问过，则访问该下标后标记已被访问
        {
            printf("%c ",G->data[index]); //访问该元素

            G->flag[index] = 1;  // 标记该元素已被访问
        }

        for( int i = 0 ; i < G->data_n ; i++ ) //遍历与index相关的二维数组的一行数据
        {
            if( G->edge_data[index][i] == 1 && G->flag[i] == 0 ) // 如果该数据不为0，且未被标记过，则入队
            {
                input_seqqueue(Q,i);
            }
        }
    }




}

深度遍历

借助栈实现深度遍历

//深度遍历DFS
int DFS_seqG( pseqG G   )
{
    if( NULL == G )
    {
        return -1;
    }

    //将G中的flag数组置0
    memset(G->flag,0,sizeof(G->flag));

    //创建栈
    pseqstack T = init_seqstack();
    if( NULL == T )
    {
        return -1;
    }

    //将图G的一个开始节点入栈
    input_seqstack(T,0);


    while( 0 != empty_seqstack(T))
    {
        int index = cat_seqstack(T);  //访问栈顶元素

        //如果没有访问就访问且标记
        if( G->flag[index] == 0 )
        {
            printf("%c ",G->data[index]);//访问
            G->flag[index] = 1 ;  //标记
        }
        
        int flag = 0 ;
        for( int i = 0 ; i < G->data_n ; i++ )
        {
            if( G->edge_data[index][i] == 1 && G->flag[i] == 0 )
            {
                input_seqstack(T,i);
                flag = 1 ;
            }
        }
        if( 0 == flag )
        {
            out_seqstack(T);
        }
    
    }
}

深度遍历（递归实现）

//深度遍历DFS（递归）
int DDFS_seqG( pseqG G , int V  )
{
    if( NULL == G )
    {
        return -1;
    }
    G->flag[V]= 1;//先标记顶点被访问
    printf(" %c", G->data[V]);
    for(int i=0;i<G->data_n;i++)
    {
        //遍历顶点的邻接点
        if(G->edge_data[V][i] == 1 && !(G->flag[i]))
        {
            DDFS_seqG(G,i);//如果邻接点可达并且没有被访问过，那么以邻接点为顶点再次进行深度优先遍历
        }
    }
    return 0;
}

完整功能代码

/*===============================================
*   文件名称：seqG.c
*   创 建 者: 
*   创建日期：2023年08月13日
*   描    述：
================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "seqG.h"
#include "seqqueue.h"
#include "seqstack.h"
//创建图
pseqG init_seqG()
{
    pseqG G = (pseqG) malloc(sizeof(seqG));
    if( NULL == G )
    {
        return NULL ;
    }
    
    memset(G->flag,0,sizeof(G->flag));

    //获取顶点个数
    puts("输入顶点个数：");
    scanf("%d",&(G->data_n));
    getchar();

    //获取顶点
    puts("请输入顶点：");
    for(int i = 0 ; i < G->data_n ; i++ )
    {
        seqG_data i_data ;
        scanf("%c",&i_data);
        G->data[i] = i_data;
    }
    getchar();

    /*
    //获取边数
    puts("请输入边数：");
    scanf("%d",&(G->data_v));
    getchar();
    */
    
    memset(G->edge_data,0,sizeof(G->edge_data));//初值为0

    //获取边的关系;
    puts("边的关系:");
    for(int i = 0 ; i < G->data_n ; i++ )
    {
        for(int j = 0 ; j < G->data_n ; j++ )
        {
            printf("%c——%c:",G->data[i],G->data[j]);
            scanf("%d",&G->edge_data[i][j]);

        }
    }
        getchar();

    return G ;
}


//图展示
int show_seqG( pseqG G )
{
    if( NULL == G )
    {
        return -1;
    }
    

    puts("矩阵：");
    for( int i = 0 ; i <G->data_n ; i++ )
    {
        for( int j = 0 ; j < G->data_n ; j++ )
        {
            printf("%4d",G->edge_data[i][j]);
        }
        puts("");
    }

    return 0;
}

//广度遍历BFS
int BFS_seqG( pseqG G )
{
    if( NULL == G )
    {
        return -1;
    }
    
    //将G中的flag数组置0
    memset(G->flag,0,sizeof(G->flag));

    //创建一个队列
    psqueue Q =  init_seqqueue();
    if( 0 == Q )
    {
        return -1;
    }

    //将图G的一个开始节点的下标入队
    if( 0 != input_seqqueue(Q,0))
    {
        printf("input queue err\n");
        return -1;
    }

    while( 0 != empty_seqqueue(Q)) //队列不为空时一直循环
    {
        int index = out_seqqueue(Q); //队列出队，记录出队元素为index

        if( G->flag[index] == 0 ) //如果该下标未被访问过，则访问该下标后标记已被访问
        {
            printf("%c ",G->data[index]); //访问该元素

            G->flag[index] = 1;  // 标记该元素已被访问
        }

        for( int i = 0 ; i < G->data_n ; i++ ) //遍历与index相关的二维数组的一行数据
        {
            if( G->edge_data[index][i] == 1 && G->flag[i] == 0 ) // 如果该数据不为0，且未被标记过，则入队
            {
                input_seqqueue(Q,i);
            }
        }
    }




}

//深度遍历DFS（递归）
int DDFS_seqG( pseqG G , int V  )
{
    if( NULL == G )
    {
        return -1;
    }
    G->flag[V]= 1;//先标记顶点被访问
    printf(" %c", G->data[V]);
    for(int i=0;i<G->data_n;i++)
    {
        //遍历顶点的邻接点
        if(G->edge_data[V][i] == 1 && !(G->flag[i]))
        {
            DDFS_seqG(G,i);//如果邻接点可达并且没有被访问过，那么以邻接点为顶点再次进行深度优先遍历
        }
    }
    return 0;
}

//深度遍历DFS
int DFS_seqG( pseqG G   )
{
    if( NULL == G )
    {
        return -1;
    }

    //将G中的flag数组置0
    memset(G->flag,0,sizeof(G->flag));

    //创建栈
    pseqstack T = init_seqstack();
    if( NULL == T )
    {
        return -1;
    }

    //将图G的一个开始节点入栈
    input_seqstack(T,0);


    while( 0 != empty_seqstack(T))
    {
        int index = cat_seqstack(T);  //访问栈顶元素

        //如果没有访问就访问且标记
        if( G->flag[index] == 0 )
        {
            printf("%c ",G->data[index]);//访问
            G->flag[index] = 1 ;  //标记
        }
        
        int flag = 0 ;
        for( int i = 0 ; i < G->data_n ; i++ )
        {
            if( G->edge_data[index][i] == 1 && G->flag[i] == 0 )
            {
                input_seqstack(T,i);
                flag = 1 ;
            }
        }
        if( 0 == flag )
        {
            out_seqstack(T);
        }
    
    }

}

三、测试代码

/*===============================================
*   文件名称：main.c
*   创 建 者:  
*   创建日期：2023年08月13日
*   描    述：
================================================*/
#include <stdio.h>
#include <string.h>
#include "seqG.h"
int main(int argc, char *argv[])
{ 

    pseqG G = init_seqG();
    if( NULL == G )
    {
        puts(" init err ");
        return -1;
    }

    show_seqG(G);

    puts("BFS");
    BFS_seqG(G);
    puts("");


    puts("DFS");
    DFS_seqG(G);
    puts("");

    memset(G->flag,0,sizeof(G->flag));
    puts("DFS（递归）");
    DDFS_seqG(G,0);
    puts("");


    return 0;
}

四、结果截图

在这里插入图片描述

南城花開
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构能够解决什么实质问题
weixin_35748962的博客
02-09 555
数据结构是一种组织、管理数据的方法，它能够帮助我们解决以下实质问题： 数据存储：数据结构可以提供一种有效的存储数据的方式。 数据查询：数据结构可以帮助我们快速查询数据。 数据排序：数据结构可以帮助我们对数据进行排序。 数据修改：数据结构可以帮助我们快速修改数据。 数据分析：数据结构可以帮助我们对数据进行分析。 总之，数据结构是处理数据的一种高效方法，能够有效地解决数据的存储、查询、排...
数据结构—图的应用
最新发布
Nancy的博客
08-14 692
图的应用包括如何构造最小生成树、最短路径（Dijkstra，Floyd）以及拓扑排序等
数据结构——图
qq_42106610的博客
12-18 5275
图——定义、分类、术语、常用表示方法、常用操作、代码（分别用邻接矩阵和邻接表两种方法实现）
【数据结构】图的详细分析（全）
码农研究僧的博客
12-27 4173
目录前言1. 定义2. 存储结构2.1 邻接矩阵2.2 邻接表3. 图的遍历3.1 深度优先搜索3.2 广度优先搜索 前言 以下笔记是天勤版本的考研数据结构数据书籍 通过参考其书籍做下的笔记 图是一种比线性表和树更为复杂的数据结构。在线性表中，数据元素之间仅有线性关系，每个数据元素只有一个直接前驱和一个直接后继；在 树形结构中，数据元素之间有着明显的层次关系，并且每一层中的数据元素可能和下一层中的多个元素（即其孩子结点）相关，但只能和上一层中一个元素（即其双亲结点）相关； 而在图结构中，结点之间的关系可以是
数据结构-图-认识
我思故我在
12-09 1421
什么是图？ 思绪：还记的第一次接触这个数据结构的时候是很多年前，书本上考题，要写出拓扑顺序，选最优路径什么的，那时候还是用大脑来‘运算’这些问题，而现在我却用电脑代码来实现当初的问题，来解决更复杂的问题，每当学一个东西我都会想，这个东西有啥用，还记得当年第一次看图这个数据结构，我立马就想到了网络拓扑图路由路径之类，我想那应该就是图的应用场景，而现在我知道了图的更多应用场景，读完本篇文章，你会知道，图可以解决那些问题，图的全量数据结构（减掉一些也可以完成要解决的问题，看场景），如何把其他图的...
数据结构——————KMP算法
03-12
数据结构——————KMP算法
数据结构实验——图
04-06
文件：包括图的文件存储，及对照表。代码：包括从文件读取并创建图，打印图的两种遍历序，深/广度优先遍历生成树或森林，Prim算法，Kruskal算法，Dijkstra算法，Floyd算法，求解AOE网关键路径。包含相应头文件及cpp...
数据结构实验——查找子系统
07-31
数据结构实验——查找子系统是IT领域中一项基础但至关重要的实践任务，它涉及到数据的组织、存储和访问策略。这个实验主要关注两种查找方法——顺序查找和二分查找，以及二叉排序树的相关操作，包括查找、插入、删除...
数据结构课设——作业管理系统
03-31
在本项目“数据结构课设——作业管理系统”中，我们主要关注的是利用C++编程语言设计和实现一个能够管理学生作业信息的系统。这个系统旨在提高教育环境中的作业管理效率，方便教师查看和处理学生的作业提交情况。在...
数据结构关于图的问题
06-30
数据结构中图的遍历，最小生成树，最短路径等等。
数据结构——图の选择题整理
王王仙贝的博客
07-20 3840
1、若从无向图的任意顶点出发进行一次深度优先搜索即可访问所有顶点，则该图一定是（）A、强连通图B、连通图C、有回路D、一棵树解析选对于A，强连通图的概念是在有向图中的。对于B，连通图证明任意两个顶点之间一定能够相连，因此一定可以到达。对于C，有环图不一定是连通图不一定任意两个顶点均能到达。对于D，树是可以，但是不是树也可以，题目中说的太肯定了，不能选，比如下图就不是树，但可以完成题目中要求的功能。2、对于一个有n个顶点的图若是连通无向图，其边的个数至少为（）；...
数据结构——图总结
m0_52711790的博客
11-19 4221
一、图的起源 众所周知，图论起源于一个非常经典的问题——柯尼斯堡（Konigsberg）问题。 十八世纪，有一座古老而美丽的城市叫做哥尼斯堡（今俄罗斯加里宁格勒）。布勒格尔河的两条支流在这里汇合，然后横贯全城，流入大海。河心有一个小岛。河水把城市分成了４块，于是，人们建造了７座各具特色的桥，把哥尼斯堡连成一体。当时那里的居民都热衷于一种游戏：看谁能从某点出发一次走遍这七座桥，每座桥只走一次，最后回到原出发点。在众多尝试者中竟无一人成功。 1738年，瑞士数学家欧拉( Leornhard Eu.
关于图的介绍
qq_44126789的博客
07-23 528
图：元素之间存在多对多关系（线性表的元素之间存在前驱和后继，树的元素之间存在父子关系，图的任意元素之间都有可能存在关系）。 由顶点的有穷非空集合和顶点之间边的集合组成。 在图型数据结构中，数据被称为顶点，数据之间的关系补称为边。 在图中不允许出现没有点，但可以没有边。 G(V,E),V表示顶点的集合，E表示边的集合。 各种图的定义： 无向图：顶点与顶点之间没有方向，这种边称为无向边，边用无向序偶对...
数据结构：图（三） 图的应用
Viadimir的博客
05-16 7139
这篇文章讲一下图的一些应用。 一、最小连通代价问题 无向连通图的生成树有很多，如果图的边具有权值，那么各个生成树的边的权值之和大小就不同。在所有生成树中，权值之和最小的一棵成为最小生成树。 1.最小生成树：假设图是一个加权连通图，具有最小权值之和的生成树称为最小代价生成树。Minimum Cost Spanning Tree (MST) 举一个例子：假设有一个网络，用以表示n个城市之间假设通信线路，边上的权值代表架设通信线路的成本。如何架设才能使线路架设成本达到最小？ 这个问题的答案：
数据结构和算法：图
JackChan
01-04 3329
图（Graph）是一种较树更为复杂的非线性数据结构。在树形结构中，数据元素之间的关系是层次型的，树中除叶子以外的每一个数据元素可以和它下一层的多个数据元素存在关系；但除根元素以外的每一个数据元素只能且必须和它上一层中的一个数据元素存在关系。而在图形结构中，数据元素之间的关系是任意的，图中每一个数据元素可以和任何其它数据元素相关联。图的基本概念图的术语1．完全图(complete graph)：在有n
数据结构中的图有哪些应用
weixin_30902675的博客
06-21 1855
我突然灵光一现 转载于:https://www.cnblogs.com/yfish/p/7062130.html
数据结构--图的应用
记录学习的博客
12-11 2975
数据结构--图的应用：最小生成树、最短路径、AOV网（涉及到拓扑排序）、AOE网（涉及到关键路径）
图数据结构实现——算法与数据结构课程设计
"算法与数据结构课程设计之图" 本课程设计主要围绕图这一数据结构展开，包括了四种类型的图（有向图、有向网、无向图、无向网）的设计与实现，以及两种数据存储结构（邻接矩阵和邻接表）。此外，还涵盖了线性表、栈...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值