[数据结构]：23-图（邻接表）（C语言实现）

最新推荐文章于 2023-12-09 16:36:12 发布
最新推荐文章于 2023-12-09 16:36:12 发布
阅读量372 收藏 2
点赞数
分类专栏： 数据结构（C语言版） 文章标签： 考研 数据结构 c语言 c++ 邻接表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55143210/article/details/129928329
版权

目录

前言

已完成内容

图实现

01-开发环境

02-文件布局

03-代码

01-主函数

02-头文件

03-AdjListCommon.cpp

04-AdjListFunction.cpp

结语

前言

        此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。

已完成内容

[数据结构]：01-顺序表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：02-单链表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：03-栈（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：04-循环队列（数组）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：05-循环队列（链表）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：06-队列（链表带头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：07-二叉树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：08-顺序查找（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：09-二分查找（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：10-二叉排序树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：11-冒泡排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：12-快速排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：13-插入排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：14-选择排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：15-堆排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：16-归并排序（顺序表指针实现形式）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：17-双链表（带头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：18-链栈（不带头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：19-串KMP模式匹配（数组）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：20-线索二叉树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：21-并查集（数组）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：22-图（邻接矩阵）（C语言实现）_Chandni.的博客-CSDN博客

图实现

01-开发环境

        语言：C/C++14

        编译器：MinGW64

        集成开发环境：CLion2022.1.3

02-文件布局

        请在CLion集成开发环境中创建C++可执行程序，否则无法运行，原因上面已解释。

                        ​​​​​              

03-代码

01-主函数

        用于测试。

// 默认为无向图，若为有向图或网，请适当修改
#include "./Head/AdjList.h"
#include "./Source/AdjListCommon.cpp"
#include "./Source/AdjListFunction.cpp"

int main() {
    ALGraph AdjList;
    InitGraph(AdjList);
    CreateGraph(AdjList);
    PrintGraph(AdjList);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 判断两结点是否存在某边
    if (Adjacent(AdjList, 0, 1)) {
        printf("true\n");
    } else {
        printf("false\n");
    }
    if (Adjacent(AdjList, 2, 3)) {
        printf("true\n");
    } else {
        printf("false\n");
    }
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 列出与x邻接的边
    int Edge[MAXSIZE] = {-1, -1, -1, -1, -1};
    Neighbors(AdjList, 0, Edge);
    for (int i = 0; Edge[i] != -1; i++) {
        printf("%3d", Edge[i]);
    }
    printf("\n");
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 删除顶点
    DeleteVertex(AdjList, 0);
    PrintGraph(AdjList);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 添加顶点
    InsertVertex(AdjList, 4);

    // 添加边
    AddEdge(AdjList, 1, 4);
    PrintGraph(AdjList);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 删除边
    RemoveEdge(AdjList, 0, 1); // 不执行
    RemoveEdge(AdjList, 1, 2);
    PrintGraph(AdjList);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");

    // 寻找第一个邻接点
    int Neighbor = FirstNeighbor(AdjList, 1);
    printf("FirstNeighbor = %d\n", Neighbor);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");
    // 寻找除4之外的下一个邻接点
    Neighbor = NextNeighbor(AdjList, 1, 4);
    printf("FirstNeighbor = %d\n", Neighbor);
    printf("VertexNum = %d,ArcNum = %d\n", AdjList.VexNum, AdjList.ArcNum);
    printf("-----------------------------------\n");
    return 0;
}

02-头文件

        用于存储结构体和常量等。

//
// Created by 24955 on 2023-04-02.
// 默认为无向图，若为有向图或网，请适当修改
//

#ifndef INC_01_ADJACENTList_ADJList_H
#define INC_01_ADJACENTList_ADJList_H
// 头文件
#include <stdio.h>
#include <stdlib.h>

// 常量
#define MAXSIZE 5
typedef int VertexType;
typedef int EdgeType;

// 结构体-弧结点
typedef struct ArcNode {
    VertexType AdjVertex;
    struct ArcNode *next;
} ArcNode;
// 结构体-顶点
typedef struct {
    VertexType data;
    ArcNode *first;
} VertexNode, AdjL[MAXSIZE];
// 结构体-图
typedef struct {
    AdjL AdjList;
    int VexNum, ArcNum;
} ALGraph;
#endif //INC_01_ADJACENTList_ADJList_H

03-AdjListCommon.cpp

        用于存储初始化图、输出图等操作。

//
// Created by 24955 on 2023-04-02.
// 默认为无向图，若为有向图或网，请适当修改
//
// 初始化图
void InitGraph(ALGraph &Graph) {
    // 初始化顶点和边表
    for (int i = 0; i < MAXSIZE; i++) {
        Graph.AdjList[i].data = -1;
        Graph.AdjList[i].first = NULL;
    }
    Graph.VexNum = 0;
    Graph.ArcNum = 0;
}

// 创建图 - 主要方便测试，并非图的正确创建方式，应根据具体情况具体分析
void CreateGraph(ALGraph &Graph) {
    Graph.VexNum = 4;
    ArcNode *arcNode[4];
    for (int i = 0; i < Graph.VexNum; i++) {
        Graph.AdjList[i].data = i;
        ArcNode *p = (ArcNode *) malloc(sizeof(ArcNode));
        p->AdjVertex = i;
        p->next = NULL;
        arcNode[i] = p;
    }
    // 无向图
    /*
     *  1. 0->1->3
     *  2. 1->0->2
     *  3. 2->1
     *  4. 3->0*/
    Graph.AdjList[0].first = arcNode[1];
    arcNode[1]->next = arcNode[3];
    Graph.AdjList[1].first = arcNode[0];
    arcNode[0]->next = arcNode[2];
    // 顶点1已经使用过，应重新申请空间
    ArcNode *p = (ArcNode *) malloc(sizeof(ArcNode));
    p->AdjVertex = 1;
    p->next = NULL;
    Graph.AdjList[2].first = p;
    ArcNode *p1 = (ArcNode *) malloc(sizeof(ArcNode));
    p1->AdjVertex = 0;
    p1->next = NULL;
    Graph.AdjList[3].first = p1;
    Graph.ArcNum = 3;
}

// 输出邻接矩阵
void PrintGraph(ALGraph Graph) {
    for (int i = 0; i < MAXSIZE; i++) {
        printf("%2d\t", Graph.AdjList[i].data);
        ArcNode *p = Graph.AdjList[i].first;
        while (p) {
            printf("%2d", p->AdjVertex);
            p = p->next;
        }
        printf("\n");
    }
}

04-AdjListFunction.cpp

        用于存储图的基本操作。

//
// Created by 24955 on 2023-04-02.
// 默认为无向图，若为有向图或网，请适当修改
//
// 获取元素下标
int GetIndex(ALGraph Graph, VertexType x) {
    /*
     *  1. 获取元素真实下标*/
    int xIndex = -1;
    for (int i = 0; i < MAXSIZE; i++) {
        if (Graph.AdjList[i].data == x) {
            xIndex = i;
            break;
        }
    }
    return xIndex;
}

// 判断图中是否存在边<x,y>
bool Adjacent(ALGraph Graph, VertexType x, VertexType y) {
    /*
     *  1. 判断x->y是否存在边
     *  2. 存在返回true*/
    // 避免访问到不存在顶点
    if (x >= MAXSIZE || y >= MAXSIZE) {
        return false;
    }
    int xIndex = GetIndex(Graph, x);
    ArcNode *p = Graph.AdjList[xIndex].first;
    while (p) {
        if (p->AdjVertex == y) {
            return true;
        }
        p = p->next;
    }
    return false;
}

// 列出图中与顶点x邻接的边
void Neighbors(ALGraph Graph, VertexType x, int *Edge) {
    /*
     * 1. 遍历x所在行
     * 2. 用数组存储与之邻接的边另一个顶点*/
    int xIndex = GetIndex(Graph, x);
    // 未找到顶点x
    if (xIndex == -1) {
        return;
    }
    // 找到顶点x，统计x邻接顶点
    ArcNode *p = Graph.AdjList[xIndex].first;
    for (int i = 0; p; i++) {
        Edge[i] = p->AdjVertex;
        p = p->next;
    }
}

// 插入顶点x
void InsertVertex(ALGraph &Graph, VertexType x) {
    /*
     *  1. 插入，顶点个数+1*/
    if (Graph.VexNum == MAXSIZE) {
        return;
    }
    for (int i = 0; i < MAXSIZE; i++) {
        if (Graph.AdjList[i].data == -1) {
            Graph.AdjList[i].data = x;
            break;
        }
    }
    Graph.VexNum++;
}

// 删除边表某结点
void DeleteArcNode(ALGraph &Graph, int xIndex, VertexType x) {
    ArcNode *pre = Graph.AdjList[xIndex].first, *p;
    if (pre == NULL) {
        return;
    }
    // 若为第一个元素
    if (pre->AdjVertex == x) {
        Graph.AdjList[xIndex].first = pre->next;
        free(pre);
    } else {
        // 不是第一个元素
        p = pre->next;
        while (p) {
            if (p->AdjVertex == x) {
                pre->next = p->next;
                free(p);
                break;
            }
            p = p->next;
        }
    }
}

// 删除顶点x
void DeleteVertex(ALGraph &Graph, VertexType x) {
    /*
     *  1. 清除顶点，并修改顶点个数
     *  2. 清除边，并修改边个数*/
    // 清除顶点,将其值设为-1表示该顶点为空,并清除相应边
    int xIndex = GetIndex(Graph, x);
    if (xIndex == -1) {
        return;
    }
    ArcNode *p = Graph.AdjList[xIndex].first;
    while (p) {
        DeleteArcNode(Graph, xIndex, p->AdjVertex);
        p = Graph.AdjList[xIndex].first;
        Graph.ArcNum--;
    }
    Graph.AdjList[xIndex].data = -1;
    Graph.VexNum--;
    // 清除其余边
    for (int i = 0; i < MAXSIZE; i++) {
        if (Graph.AdjList[i].data != -1) {
            DeleteArcNode(Graph, i, x);
        }
    }
}

// 在边表中插入某顶点-尾部插入(也可头部插入)
void AddArcNode(ALGraph &Graph, int xIndex, VertexType x) {
    ArcNode *NewNode = (ArcNode *) malloc(sizeof(ArcNode));
    NewNode->AdjVertex = x;
    NewNode->next = NULL;
    ArcNode *p = Graph.AdjList[xIndex].first;
    if (p == NULL) {
        Graph.AdjList[xIndex].first = NewNode;
    } else {
        while (p->next) {
            p = p->next;
        }
        p->next = NewNode;
    }
    // 头部插入
//    NewNode->next = Graph.AdjList[xIndex].first;
//    Graph.AdjList[xIndex].first = NewNode;
}

// 添加边
void AddEdge(ALGraph &Graph, VertexType x, VertexType y) {
    /*
     *  1. 获取顶点值实际下标
     *  2. 插入边*/
    int xIndex = GetIndex(Graph, x);
    int yIndex = GetIndex(Graph, y);
    if (xIndex == -1 || yIndex == -1) {
        return;
    }
    // 添加边
    AddArcNode(Graph, xIndex, y);
    AddArcNode(Graph, yIndex, x);
    Graph.ArcNum++;
}

// 删除边
void RemoveEdge(ALGraph &Graph, VertexType x, VertexType y) {
    /*
     *  1. 获取顶点值实际下标
     *  2. 删除边*/
    int xIndex = GetIndex(Graph, x);
    int yIndex = GetIndex(Graph, y);
    if (xIndex == -1 || yIndex == -1) {
        return;
    }
    // 删除边
    DeleteArcNode(Graph, xIndex, y);
    DeleteArcNode(Graph, yIndex, x);
    Graph.ArcNum--;
}

// 寻找图中顶点x的第一个邻接点
int FirstNeighbor(ALGraph Graph, VertexType x) {
    /*
     *  1. 寻找第一个不为0的值，并返回顶点值*/
    int xIndex = GetIndex(Graph, x);
    if (xIndex == -1) {
        return -1;
    }
    ArcNode *p = Graph.AdjList[xIndex].first;
    if (p != NULL) {
        return p->AdjVertex;
    }
    return -1;
}

// 图的下一个邻接点-除y以外的下一个邻接点顶点号
int NextNeighbor(ALGraph Graph, VertexType x, VertexType y) {
    /*
     *  1. 寻找y之后第一个不为0的值，并返回顶点值*/
    int xIndex = GetIndex(Graph, x);
    if (xIndex == -1) {
        return -1;
    }
    // 寻找y之后的下一个邻接点
    ArcNode *p = Graph.AdjList[xIndex].first;
    while (p) {
        if (p->AdjVertex == y) {
            break;
        }
        p = p->next;
    }
    if (p) {
        p = p->next;
        if (p) {
            return p->AdjVertex;
        }
    }
    return -1;
}

结语

        此博客主要用于408考研数据结构C语言实现记录，内有不足，可留言，可讨论。

Chandni.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构学习--图的邻接矩阵和邻接表存储
06-25
在数据结构的学习中，图是一种非常重要的非线性数据结构，用于表示对象之间的关系。图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素...
【C语言】图的邻接表——超详细解析
Jaye513的博客
12-09 4558
快看这篇，学不会你来打我（bushi）
C语言 图操作--邻接表法
qq_51838257的博客
04-13 2157
C语言 图操作–邻接表法 一、图的介绍 图是一种相较于链表和树更为复杂的数据结构。在线性表中，数据元素之间仅有线性关系，每个元素只有一个直接前驱和一个直接后继（每个元素之间一个一个逐个相连）。在树形结构中，数据元素之间有着明显的层次关系，上一层元素能和下层多个元素相关，但是下层元素只能与一个上层元素相关。而在图结构中，节点之间的关系任意，任何两个顶点都可能相连。 图结构如图所示 此中为“离散数学”中的图理论。 二、图的术语 接下来介绍图结构中的一些术语。 1.顶点 图中的数据元素通常称为顶点。 2.边
记录数据结构的学习010
qq_42394684的博客
08-14 590
(此文为王道数据结构学习笔记，只供个人后续复习使用，若有错误，还望指出我改正，谢谢） 图的遍历 广度优先遍历： 树的广度优先遍历：层序遍历，树是特殊的图
数据结构--图
qq_37617419的博客
08-22 411
**图** 新的一周，最近感觉时间过得好快啊！！！ 争取在开学前整理完！！！开学后二刷王道！！！ （加油！！！！！） 直接上图吧！ 开始正题！！ 1.图的存储 //图的邻接矩阵 #define MaxVertexNum 100 //顶点数目的最大值 typedef char VertexType;//顶点的数据类...
图的广度优先算法全部代码，使用邻接矩阵，包括FirstNeighbor函数以及NextNeighbor函数的实现
强仔的博客
05-26 1219
话不多说，直接上代码，注意代码中顶点的序号是从1开始，但是存放顶点的数组序号是从0开始，所以在代码中需要实现一个函数该函数来通过顶点找到对应的下标，辅助队列使用的是带头结点的链式队列。下图来自王道考研视频，验证中也是从顶点1开始遍历，当然可以自己指定顶点进行验证。注意，边数以及顶点数也可以自己输入，我这里是直接进行赋值了，最后进行验证。
数据结构-c语言-带main函数-图7.2-图的存储结构-图的邻接表的创建-无向图。
06-24
数据结构 - 图的存储结构 - 邻接表的创建 - 无向图。 在数据结构中，图是一种非常重要的数据结构，它广泛应用于计算机科学和信息技术领域中。在本节中，我们将讨论图的存储结构，并使用 C 语言实现图的邻接表的创建...
c语言数据结构图的相关操作源码-邻接表邻接矩阵等
11-07
本话题主要关注图数据结构及其在C语言中的实现，包括邻接表和邻接矩阵两种常见的表示方法。 **图数据结构**： 图是由顶点（节点）和边组成的非线性数据结构，可以用来表示对象之间的关系。图可以是无向的，即任意两...
数据结构-c语言-带main函数-图7.3-图的遍历-广度优先搜索-队列-邻接表-无向图。
06-24
在本文中，我们将深入探讨如何使用C语言实现无向图的广度优先搜索（BFS）遍历，其中涉及到了数据结构如邻接表、队列，并使用了CFree软件进行辅助开发。首先，让我们详细了解这些概念。 **数据结构：邻接表** 邻接表...
C语言数据结构-邻接表的广度优先遍历
最新发布
12-13
C语言数据结构-邻接表的广度优先遍历
有向图的邻接表(C语言)
06-17
c语言写的有向图的邻接表的实现，通过使用图的邻接表实现图的存储结构存储。
c语言实现的邻接表连通图深度优先遍历
04-26
c语言实现的邻接表连通图深度优先遍历，包括图的邻接表建立，图的深度优先遍历
C语言邻接表法的实现
m0_53707852的博客
08-20 381
C语言邻接表法的实现
图的邻接表
yanwuxiuwen的博客
05-31 4528
图的邻接表存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。如词条概念图所示，表结点存放的是邻接顶点在数组中的索引。对于无向图来说，使用邻接表进行存储也会出现数据冗余，表头结点A所指链表中存在一个指向C的表结点的同时，表头结点C所指链表也会存在一个指向A的表结点。 [1] 邻接表是图的一种最主要存储结构,用来描述图上的每一个点。对图的每个顶点建立一个容器（n个顶点建立n个容器），第i个容器中的
C语言图的邻接表存储
记录学习点滴
04-24 5895
1.邻接表法 邻接表有两个部分：顶点节点、边节点 （1）顶点节点 建立一个顺序表，用来存储图中所有顶点。每个顶点为表中一个元素，每个元素包含：数据域和指针域（firstedge） 数据域：存储节点信息，如节点名称 指针域：指向顶点的第一个邻接点 存储结构如下： #define MAX_VERTEX_NUM 100 /* 图中最大节点数 */ typedef struct vnod...
【八】【数据结构】邻接表，图，代码简单实现，深度解析
m0_74163972的博客
12-09 590
我们今天学习了邻接表存储图信息，需要三个结构体，第一个是图的结构体，第二个是顶点结构体，第三个是表结构体（也是表示顶点）。接着编写顶点结构体，成员信息要包括该顶点的信息data，也就是顶点的表示信息，我们这里用数组对应下标表示该信息，还有一个指向表结点的指针，也就是邻接表，用来表示该顶点的邻接表，达到遍历某一顶点中邻接表的所有元素的效果。从图结构体开始编写，成员信息要包括图中顶点的个数，边的个数，图的类型，以及一个数组vex，存储每一个顶点。可以验证，用邻接表表示出来的图是没有问题的。
C语言实现图的邻接表
M_H_T__的博客
12-24 2668
笔者通过纯C语言实现图的邻接表表示法 （单向有权图） 涉及操作有： 图顶点的 增 删 改 查 图边的 增 删 改 查 打印邻接表 迪杰斯特拉算法 求最短路径（包括中转节点的记录） 部分原理限于篇幅会做介绍，但关键在于自己搜寻资料学习 此博客目的在于分享心得 图的原理构造（篇末源代码也是复现如此结构）如下： 注意：此结构进行过改动，会与部分图书有出入。 因为涉及图顶点（节点）的增删改查，故对顶点的...
【数据结构】图的存储结构之邻接表（C语言）
xiangjunyes的博客
07-08 4458
我们把数组与链表相结合的存储方法称为邻接表（Adjacency List）。 邻接表的处理办法是这样的： 图中顶点用一个一维数组存储，当然顶点也可以用单链表来存储，不过数组可以较容易地读取顶点信息，更加方便。另外，对于顶点数组中，每个数据元素还需要存储指向第一个邻接点的指针，以便以查找该顶点的信息。 图中每个顶点Vi的所有邻接点构成一个线性表，由于邻接点的个数不定，所以用单链表存储，无向图称为顶点vi的边表，有向图则称为顶点vi作为弧尾的出边表。 如图1-1就是一个无向图的邻接表结构。 图1-1. 从图
图之邻接表详解（C语言版）
qq_44075108的博客
04-25 9497
图之邻接表详解（C语言版）
数据结构邻接表C语言实现
07-13
邻接表是一种表示图的数据结构，可以用来存储图的顶点和边。在C语言中，可以使用链表来实现邻接表。 首先，我们需要定义图的顶点结构体和边结构体： ```c // 边的结构体 typedef struct Edge { int dest; // 边的目标顶点 struct Edge* next; // 指向下一条边的指针 } Edge; // 顶点的结构体 typedef struct Vertex { int value; // 顶点的值 Edge* head; // 指向第一条边的指针 } Vertex; ``` 然后，我们可以定义邻接表的结构体，其中包含顶点数组和顶点数量： ```c typedef struct Graph { int numVertices; // 顶点数量 Vertex* vertices; // 顶点数组 } Graph; ``` 接下来，我们可以实现邻接表的创建函数、添加边的函数和打印函数： ```c // 创建图的邻接表 Graph* createGraph(int numVertices) { Graph* graph = (Graph*)malloc(sizeof(Graph)); graph->numVertices = numVertices; graph->vertices = (Vertex*)malloc(numVertices * sizeof(Vertex)); // 初始化顶点数组 for (int i = 0; i < numVertices; i++) { graph->vertices[i].value = i; graph->vertices[i].head = NULL; } return graph; } // 添加边到图的邻接表 void addEdge(Graph* graph, int src, int dest) { Edge* newEdge = (Edge*)malloc(sizeof(Edge)); newEdge->dest = dest; newEdge->next = graph->vertices[src].head; graph->vertices[src].head = newEdge; // 无向图需添加反向边 newEdge = (Edge*)malloc(sizeof(Edge)); newEdge->dest = src; newEdge->next = graph->vertices[dest].head; graph->vertices[dest].head = newEdge; } // 打印图的邻接表 void printGraph(Graph* graph) { for (int i = 0; i < graph->numVertices; i++) { printf("顶点 %d 的边：", i); Edge* curr = graph->vertices[i].head; while (curr != NULL) { printf(" -> %d", curr->dest); curr = curr->next; } printf("\n"); } } ``` 现在，我们可以在主函数中使用这些函数来创建图、添加边并打印邻接表： ```c int main() { int numVertices = 5; Graph* graph = createGraph(numVertices); addEdge(graph, 0, 1); addEdge(graph, 0, 4); addEdge(graph, 1, 2); addEdge(graph, 1, 3); addEdge(graph, 1, 4); addEdge(graph, 2, 3); addEdge(graph, 3, 4); printGraph(graph); return 0; } ``` 运行以上代码，将输出如下结果： ``` 顶点 0 的边： -> 4 -> 1 顶点 1 的边： -> 4 -> 3 -> 2 -> 0 顶点 2 的边： -> 3 -> 1 顶点 3 的边： -> 4 -> 2 -> 1 顶点 4 的边： -> 3 -> 1 -> 0 ``` 这样，我们就完成了邻接表的C语言实现。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chandni.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值