王道数据结构代码---第六章：图

最新推荐文章于 2023-07-18 17:42:40 发布
最新推荐文章于 2023-07-18 17:42:40 发布
阅读量308 收藏
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinzhi66/article/details/125902074
版权

目录

有向图

 无向图

 图的存储

        邻接矩阵法

        邻接表法

        完整代码

图的定义：

有向图

 无向图

 

 图的存储（重要）

        邻接矩阵法

 

        邻接表法

完整代码

#define  _CRT_SECURE_NO_WARNINGS   //解决scanf编译报错问题
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>

#define MAX 100
#define isLetter(a)  ((((a)>='a')&&((a)<='z')) || (((a)>='A')&&((a)<='Z')))
#define LENGTH(a)  (sizeof(a)/sizeof(a[0]))

// 邻接表中表对应的链表的顶点
typedef struct _ENode
{
    int ivex;                   // 该边所指向的顶点的位置,是数组的下标
    struct _ENode* next_edge;   // 指向下一条弧的指针
}ENode, * PENode;

// 邻接表中表的顶点
typedef struct _VNode
{
    char data;              // 顶点信息
    ENode* first_edge;      // 指向第一条依附该顶点的弧
}VNode;

// 邻接表
typedef struct _LGraph
{
    int vexnum;             // 图的顶点的数目
    int edgnum;             // 图的边的数目
    VNode vexs[MAX];
}LGraph;

/*
 * 返回ch在matrix矩阵中的位置
 */
static int get_position(LGraph g, char ch)
{
    int i;
    for (i = 0; i < g.vexnum; i++)
        if (g.vexs[i].data == ch)
            return i;
    return -1;
}

/*
 * 读取一个输入字符
 */
static char read_char()
{
    char ch;

    do {
        ch = getchar();
    } while (!isLetter(ch));

    return ch;
}

/*
 * 将node链接到list的末尾
 */
static void link_last(ENode* list, ENode* node)
{
    ENode* p = list;

    while (p->next_edge)
        p = p->next_edge;
    p->next_edge = node;
}

/*
 * 创建邻接表对应的图(自己输入)
 */
LGraph* create_lgraph()
{
    char c1, c2;
    int v, e;
    int i, p1, p2;
    ENode* node1, * node2;
    LGraph* pG;

    // 输入"顶点数"和"边数"
    printf("input vertex number: ");
    scanf("%d", &v);
    printf("input edge number: ");
    scanf("%d", &e);
    if (v < 1 || e < 1 || (e > (v * (v - 1))))
    {
        printf("input error: invalid parameters!\n");
        return NULL;
    }

    if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = v;
    pG->edgnum = e;
    // 初始化"邻接表"的顶点
    for (i = 0; i < pG->vexnum; i++)
    {
        printf("vertex(%d): ", i);
        pG->vexs[i].data = read_char();
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for (i = 0; i < pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        printf("edge(%d): ", i);
        c1 = read_char();
        c2 = read_char();

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);

        // 初始化node1
        node1 = (ENode*)calloc(1, sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if (pG->vexs[p1].first_edge == NULL)
            pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
        // 初始化node2
        node2 = (ENode*)calloc(1, sizeof(ENode));
        node2->ivex = p1;
        // 将node2链接到"p2所在链表的末尾"
        if (pG->vexs[p2].first_edge == NULL)
            pG->vexs[p2].first_edge = node2;
        else
            link_last(pG->vexs[p2].first_edge, node2);
    }

    return pG;
}

/*
 * 创建邻接表对应的图(用已提供的数据)，无向图
 */
LGraph* create_example_lgraph()
{
    char c1, c2;
    char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    char edges[][2] = {
        {'A', 'C'},
        {'A', 'D'},
        {'A', 'F'},
        {'B', 'C'},
        {'C', 'D'},
        {'E', 'G'},
        {'F', 'G'} };
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    //上面类似一个邻接矩阵存储
    int i, p1, p2;
    ENode* node1, * node2;
    LGraph* pG;


    if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = vlen;
    pG->edgnum = elen;
    // 初始化"邻接表"的顶点
    for (i = 0; i < pG->vexnum; i++)
    {
        pG->vexs[i].data = vexs[i];
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for (i = 0; i < pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = edges[i][0];
        c2 = edges[i][1];

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);

        // 初始化node1
        node1 = (ENode*)calloc(1, sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if (pG->vexs[p1].first_edge == NULL)
            pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
        // 初始化node2
        node2 = (ENode*)calloc(1, sizeof(ENode));
        node2->ivex = p1;
        // 将node2链接到"p2所在链表的末尾"
        if (pG->vexs[p2].first_edge == NULL)
            pG->vexs[p2].first_edge = node2;
        else
            link_last(pG->vexs[p2].first_edge, node2);
    }

    return pG;
}

/*
 * 深度优先搜索遍历图的递归实现
 */
static void DFS(LGraph G, int i, int* visited)
{
    ENode* node;

    visited[i] = 1;
    printf("%c ", G.vexs[i].data);
    node = G.vexs[i].first_edge;
    while (node != NULL)
    {
        if (!visited[node->ivex])//只要对应顶点没有访问过，深入到下一个顶点访问
            DFS(G, node->ivex, visited);
        node = node->next_edge;//某个顶点的下一条边，例如B结点的下一条边
    }
}

/*
 * 深度优先搜索遍历图
 */
void DFSTraverse(LGraph G)
{
    int i;
    int visited[MAX];       // 顶点访问标记

    // 初始化所有顶点都没有被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;

    printf("DFS: ");
    //从A开始深度优先遍历
    for (i = 0; i < G.vexnum; i++)
    {
        if (!visited[i])
            DFS(G, i, visited);
    }
    printf("\n");
}

/*
 * 广度优先搜索（类似于树的层次遍历）
 */
void BFS(LGraph G)
{
    int head = 0;
    int rear = 0;
    int queue[MAX];     // 辅组队列
    int visited[MAX];   // 顶点访问标记
    int i, j, k;
    ENode* node;

    //每个顶点未被访问
    for (i = 0; i < G.vexnum; i++)
        visited[i] = 0;
    //从零号顶点开始遍历
    printf("BFS: ");
    for (i = 0; i < G.vexnum; i++)//对每个连同分量均调用一次BFS
    {
        if (!visited[i])//如果没访问过，就打印，同时入队,最初是A
        {
            visited[i] = 1;
            printf("%c ", G.vexs[i].data);
            queue[rear++] = i;  // 入队列
        }
        while (head != rear) //第一个进来的是A，遍历A的每一条边
        {
            j = queue[head++];  // 出队列
            node = G.vexs[j].first_edge;
            while (node != NULL)
            {
                k = node->ivex;
                if (!visited[k])
                {
                    visited[k] = 1;
                    printf("%c ", G.vexs[k].data);
                    queue[rear++] = k;//类似于树的层次遍历，遍历到的同时入队
                }
                node = node->next_edge;
            }
        }
    }
    printf("\n");
}

/*
 * 打印邻接表图
 */
void print_lgraph(LGraph G)
{
    int i;
    ENode* node;

    printf("List Graph:\n");
    for (i = 0; i < G.vexnum; i++)//遍历所有的顶点
    {
        printf("%d(%c): ", i, G.vexs[i].data);
        node = G.vexs[i].first_edge;
        while (node != NULL)//把每个顶点周围的结点都输出一下
        {
            printf("%d(%c) ", node->ivex, G.vexs[node->ivex].data);
            node = node->next_edge;
        }
        printf("\n");
    }
}
/*
 * 创建邻接表对应的图(有向图)
 */
LGraph* create_example_lgraph_directed()
{
    char c1, c2;
    char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    char edges[][2] = {
        {'A', 'B'},
        {'B', 'C'},
        {'B', 'E'},
        {'B', 'F'},
        {'C', 'E'},
        {'D', 'C'},
        {'E', 'B'},
        {'E', 'D'},
        {'F', 'G'} };
    int vlen = LENGTH(vexs);
    int elen = LENGTH(edges);
    int i, p1, p2;
    ENode* node1;
    LGraph* pG;


    if ((pG = (LGraph*)malloc(sizeof(LGraph))) == NULL)
        return NULL;
    memset(pG, 0, sizeof(LGraph));

    // 初始化"顶点数"和"边数"
    pG->vexnum = vlen;
    pG->edgnum = elen;
    // 初始化"邻接表"的顶点
    for (i = 0; i < pG->vexnum; i++)
    {
        pG->vexs[i].data = vexs[i];
        pG->vexs[i].first_edge = NULL;
    }

    // 初始化"邻接表"的边
    for (i = 0; i < pG->edgnum; i++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = edges[i][0];
        c2 = edges[i][1];

        p1 = get_position(*pG, c1);
        p2 = get_position(*pG, c2);
        // 初始化node1
        node1 = (ENode*)calloc(1, sizeof(ENode));
        node1->ivex = p2;
        // 将node1链接到"p1所在链表的末尾"
        if (pG->vexs[p1].first_edge == NULL)
            pG->vexs[p1].first_edge = node1;
        else
            link_last(pG->vexs[p1].first_edge, node1);
    }

    return pG;
}
//《王道C督学营》课程
//图的创建，打印，广度优先遍历，深度优先遍历
//讲 有向图
void main()
{
    LGraph* pG;

    // 无向图自定义"图"(自己输入数据，输入的方法可以参考create_example_lgraph初始化好的数据)
    //pG = create_lgraph();
     无向图的创建，采用已有的"图"
    //pG = create_example_lgraph();
    //有向图的创建
    pG = create_example_lgraph_directed();
    // 打印图
    print_lgraph(*pG);
    DFSTraverse(*pG);//深度优先遍历
    BFS(*pG);//广度优先遍历
    system("pause");
}

jinzhi66
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
王道数据结构代码笔记
My博客
07-15 3304
数据结构考研代码
考研王道数据结构代码.zip
11-26
里面是2020王道数据结构课后习题可执行代码。https://blog.csdn.net/qq_40285036 可以参考这个博客一起学习。
王道数据结构【图】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
07-27 2479
王道数据结构【图】部分代码实现（C语言）
图的遍历和相关操作
萧西朗的博客
05-09 334
图的遍历和相关操作 参考书籍：王道--数据结构--代码在vs2019验证过！ 图的创建，打印，广度优先遍历，深度优先遍历 测试代码： #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <string.h> #include <iostream> #define MAX 100 #define isLetter(a) ((((a...
【数据结构】24王道考研笔记——图
weixin_51630192的博客
07-18 2514
【数据结构】24王道考研笔记——图
王道数据结构6（图）
沉晨尘宸的博客
08-22 1309
/对无向图，用0,1表示是否相邻，对于带权图，为权值 InfoType * info;//该弧相关信息的指针 } RrcCell , AdjMatrix [ MAX_VERTEXT_NUM ] [ MAX_VERTEXT_NUM ];//邻接矩阵20//对无向图，用0,1表示是否相邻，对于带权图，为权值 InfoType * info;//该弧相关信息的指针 } RrcCell , AdjMatrix [ MAX_VERTEXT_NUM ] [ MAX_VERTEXT_NUM ];.........
王道数据结构-第一张-绪论
02-03
王道数据结构
王道咸鱼学长408课件PDF整理（数据结构-计算机组成-操作系统）
最新发布
01-10
适合大学计算机本科生初学者，考研计算机408，王道数据结构、计算机组成、操作系统课件整理，基本上没有水印，各科合并为一个PDF文件，并且手动加上了标签，便于定位和查阅。
数据结构笔记-《考研王道笔记知识点整理》
05-23
数据结构笔记-《考研王道笔记知识点整理》/2024最新版
图的遍历 - 数据结构
weixin_30457881的博客
07-04 2709
概述 图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。图的遍历操作和树的遍历操作功能相似。图的遍历是图的一种基本操作，图的其它算法如求解图的连通性问题，拓扑排序，求关键路径等都是建立在遍历算法的基础之上。 由于图结构本身的复杂性，所以图的遍历操作也较复杂，主要表现在以下四个方面： ① 在图结构中，没有一个“自然”的首结点，图中任意一个顶点都...
创建图并将它的邻接矩阵打印出来以及将它的节点遍历出来
qq_56683739的博客
08-27 1237
一.知识概况： （1）基本概况： 图(graph)是一种非线性的结构 形式化的语言描述为Graph=(V,R)，其中 V={Vi|vi属于某种数据类型,i=0,1,2,3 ***,n}是图中元素，vi 称为顶点 。V就是顶点的集合 当n=0 时 V为空集R{<vi,vj>|vi,vj 属于V ，且p(vi,vj存在)}是图中顶点之间的关系的集合 ，p(vi,vj)为顶点vi和vj之间是否存在路径的判断条件即若 vi/vj 之间的路径存在则关系 <vi,vj>属于R。 分类有..
图论——图的遍历
m0_54566774的博客
11-30 622
现在我们来思考一个问题，图如何进行遍历？ 既然是遍历，我们想要得到的结果就是每条边所对应的两点都输出出来，且保证唯一性【即针对无向图无向网，根据对称性，一条边所对应的两点输出以后，对称的点不再输出】 接下来，我们介绍两种遍历图的思想，两种思想的共性就是他们都是从图中的任意点出发来依次遍历图【由于非连通图较复杂，因此我们下面只讨论连通图】 1.深度优先搜索 类似于树的先序遍历 过程： 从图中某个顶点v出发，访问v 找出刚访问过的顶点的未被访问的一个邻接点，访问该邻接点【在这里，我们规定优先访问数
数据结构（七）——图的遍历
LongXinKou的博客
04-25 1204
文章目录1. 图的遍历1.2 广度优先搜索 重点 深度优先遍历 广度优先遍历 图遍历算法的应用：拓扑排序、连通性问题、关键路径。 1. 图的遍历 图的遍历是指从图的某一个顶点出发，按照某种搜索方法沿着图中的边对图中的所有结点访问一次且仅一次。 1.2 广度优先搜索 （1）核心问题 搜索相邻结点 判断已经访问过的结点 辅助队列 如何处理非连通图 （2）思想 广度优先搜索类似于二叉树的层次遍历算法。 首先访问起始顶点，接着访问其未被访问过的邻近顶点。 再从被访问的顶点出发，访问它未被访问过的邻近结点。
【数据结构】图的遍历与应用
sailven的博客
09-28 434
图相关的练习和实验。时间：2020-6-7。
[数据结构]图
weixin_45326969的博客
04-23 613
[数据结构]图 图的定义和术语 图：Graph=(V,E) V:定点（数据元素）的有穷非空集合； E:边的有穷集合。 无向图：每条边都是无方向的 有向图：每条边都是有方向的 完全图：任意两个点都有一条边相连 无向完全图：n(n-1)/2条边 有向完全图：n(n-1)条边 稀疏图：有很少边或弧的图 稠密图：有较多边或弧的图 网：边/弧带权的图 邻接：有边/弧相连的两个定点之间的关系。 存在（vi，v...
王道数据结构【链表】部分代码实现（C语言）
年少的勇气已经用完，剩下的就是三思而后行
08-01 2051
王道数据结构【链表】部分代码实现（C语言）
图，图的遍历
糖哲睿的博客
06-01 2442
输入图的类型、顶点数、狐（边）数、顶点信息、狐（边）信息，建立相应的图(具体类型为有向图、无向图，采用邻接矩阵存储结构)；分别按深度优先搜索和广度优先搜索遍历图；按某种形式输出图及遍历结果 #include <stdio.h> #include <stdlib.h> #define OVERFLOW -2 #define ILLEGAL -1 ...
图的遍历方法
贾欣晓的博客
05-15 7851
从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次，这一过程就叫做图的遍历（Traversing Graph） 访问过的顶点打上标记，避免访问多次而不自知；可以通过设置一个访问数组visited[n]，n是图中顶点个数，初值为0，访问之后设置为1 图遍历要避免因回路陷入死循环，通常有两种遍历次序方案： 深度优先遍历 广度优先遍历 深度优先遍历 深度优先遍历（Depth_First_Search），也有称为深度优先搜索，简称DFS 如上图，如何从顶点A开始走遍所有的图顶点并作上标记？ 从顶点
2022版王道数据结构算法题C语言代码实现-第6章-图
DanielSYC的博客
10-16 640
概述 这是2022版王道数据结构的第6章——图的算法大题的C语言代码实现，书上的练习题主要针对图的遍历且题目很少。代码都经过了简单的测试，基本上不会有太大问题。 编译环境为gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0，文件目录结构如下： ch6 ├── 6-3-graph_traversal.c ├── 6-3-graph_traversal_test.c ├── graph_adjacency_list.h ├── graph_adjacency_matrix.h ├──
王道数据结构代码实现C语言
07-29
王道数据结构提供了一系列的代码实现，包括顺序表、链表、栈队列、二叉树、图以及查找排序等部分的代码实现。\[1\]这些代码实现使用了C语言来实现各种数据结构的功能。 例如，可以使用createDouLoopLink函数来创建...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值