无向图的邻接矩阵与邻接表详细实现

数据结构与算法王卓-习题-第六章图-创建无向图以及邻接矩阵 目录 算法描述 算法预期效果 重难点 思路 个人解法 总结 测试样例与输出 算法描述 创建无向图的邻接矩阵 算法预期效果 依次输入顶点数,边数,顶点V1~Vn,边A1~An,根据输入的顶点与边的关系,输出形如右边的邻接矩阵 重难点 本身此问题较简单,所以没什么重难点。稍微有点考虑的可能是:输出矩阵如何换行,如何根据输入边的关系转化为数组下标(也就是王老师课程中的Locate函数) 思路 盗一张自己的图(王老师课件的) 个人解法 #include <i.. 阅读详情
AI摘要

本文详细介绍了无向图的邻接矩阵表示法,通过示例展示了如何在内存中存储和操作,并与邻接表进行比较,突出了两者在表示图结构和查找效率上的差异。同时提供了C++代码实现,适用于初学者理解图数据结构。

无向图的邻接矩阵

通过用邻接矩阵来表示无向图。如下无向图G1的邻接矩阵:

无向图G1的邻接矩阵

无向图G1包含了“A, B, C, D, E, F, G”共七个顶点,而且包含了“(A, C), (A, D), (A, F), (B, C), (C, D), (E, G), (F, G)”共七条边。由于这是无向图,所以(A, C)和(C, A)是同一条边,这里列举边时,按照字母先后顺序列举的。

无向图G1右边的邻接矩阵在内存中的邻接矩阵示意图。A[i][j] = 1表示第i个顶点与第j个顶点是邻接点,A[i][j] = 0表示它们不是邻接点。而i, j表示第i行和第j列的值。如:A[1, 2] = 1 表示第1个顶点B和第二个顶点C是邻接点。

代码实现

#include <iostream>
using namespace std;

#define MAX 100

class MatrixUDG
{
private:
    char mVexs[MAX];       //顶点集合
    int mVexNum;           //顶点数
    int mEdgNum;           //边数
    int mMatrix[MAX][MAX]; //邻接矩阵
public:
    //创建图(手动输入)
    MatrixUDG();
    //创建图(用提供的顶点和边)
    MatrixUDG(char *vexs, int vNum, char (*edges)[2], int eNum);
    ~MatrixUDG();
    //打印邻接表
    void print();
    //输入一个合法字母
    char readChar();
    //获得一个字母在顶点数组的下标
    int getPosition(char ch);
};

MatrixUDG::MatrixUDG()
{
    char c1, c2;
    int p1, p2;
    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgNum;
    if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i] = readChar();
    }
    for (int j = 0; j < mEdgNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误!" << endl;
            return;
        }
        mMatrix[p1][p2] = 1;
        mMatrix[p2][p1] = 1;
    }
}

MatrixUDG::MatrixUDG(char *vexs, int vNum, char (*edges)[2], int eNum)
{
    if (vNum > MAX)
        return;
    mVexNum = vNum;
    mEdgNum = eNum;
    //初始化顶点
    for (int i = 0; i < mVexNum; ++i)
        mVexs[i] = vexs[i];
    int p1, p2;
    for (int j = 0; j < mEdgNum; ++j)
    {
        //获得边的起始点和结束点
        p1 = getPosition(edges[j][0]);
        p2 = getPosition(edges[j][1]);
        //将连线的两个点都置为1
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误!" << endl;
            return;
        }
        mMatrix[p1][p2] = 1;
        mMatrix[p2][p1] = 1;
    }
}

MatrixUDG::~MatrixUDG()
{
}

int MatrixUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i] == ch)
            return i;
    }
    return -1;
}

char MatrixUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

void MatrixUDG::print()
{
    for (int i = 0; i < mVexNum; ++i)
    {
        for (int j = 0; j < mVexNum; ++j)
        {
            cout << mMatrix[i][j] << " ";
        }
        cout << endl;
    }
}

int main()
{
    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 vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
//  MatrixUDG mudg(vexs, vNum, edges, eNum);
//  mudg.print();
    //2. 手动生成
    MatrixUDG mudg1;
    mudg1.print();
}

手动输入时运行结果如下:

输入顶点数:7
输入边数:7
vertex(0):A
vertex(1):B
vertex(2):C
vertex(3):D
vertex(4):E
vertex(5):F
vertex(6):G
edge(0):AC
edge(1):AD
edge(2):AF
edge(3):BC
edge(4):CD
edge(5):EG
edge(6):FG
0 0 1 1 0 1 0 
0 0 1 0 0 0 0 
1 1 0 1 0 0 0 
1 0 1 0 0 0 0 
0 0 0 0 0 0 1 
1 0 0 0 0 0 1 
0 0 0 0 1 1 0 

无向图的邻接表

通过用邻接表来表示无向图。如下无向图G1的邻接表:

无向图G1的邻接表

无向图G1包含了“A, B, C, D, E, F, G”共七个顶点,而且包含了“(A, C), (A, D), (A, F), (B, C), (C, D), (E, G), (F, G)”共七条边。

无向图G1右边的邻接表示意图如上图。每个顶点都包含一个链表,该链表记录了“该顶点的邻接点的序号”。顶点C包含的链表所包含的数据分别是“0、1、3”,而“0、1、3”分别对应“A、B、D”的序号,“A、B、D”都是C的邻接点。就是通过这种方式记录图的信息的。

代码实现

#include <iostream>
using namespace std;

#define MAX 100

class ListUDG
{
private:
    //每一条边
    struct ENode
    {
        int iVex;               //指向的顶点的位置
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    //数组中存储的顶点
    struct VNode
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点
public:
    ListUDG();
    ListUDG(char vexs[], int vNum, char edges[][2], int eNum);
    ~ListUDG();
    //打印邻接表
    void print();

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
};

ListUDG::ListUDG()
{
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }

        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        node2 = new ENode();
        node2->iVex = p1;
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::ListUDG(char *vexs, int vNum, char (*edges)[2], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    mVexNum = vNum;
    mEdgeNum = eNum;
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
    }
    for (int j = 0; j < mEdgeNum; ++j)
    {
        c1 = edges[j][0];
        c2 = edges[j][1];
        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        node1 = new ENode();
        node1->iVex = p2;
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        node2 = new ENode();
        node2->iVex = p1;
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::~ListUDG() {}

void ListUDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

void ListUDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    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 vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
//  ListUDG ludg(vexs, vNum, edges, eNum);
//  ludg.print();
    //2. 手动输入
    ListUDG ludg;
    ludg.print();
    return 0;
}

手动输入时运行结果如下:

输入顶点数:7
输入边数:7
vertex(0):A
vertex(1):B
vertex(2):C 
vertex(3):D
vertex(4):E
vertex(5):F
vertex(6):G
edge(0):AC
edge(1):AD
edge(2):AF
edge(3):BC
edge(4):CD
edge(5):EG
edge(6):FG
0(A):2(C)3(D)5(F)
1(B):2(C)
2(C):0(A)1(B)3(D)
3(D):0(A)2(C)
4(E):6(G)
5(F):0(A)6(G)
6(G):4(E)5(F)
基于邻接矩阵的无向图 基于邻接矩阵的无向图 什么是无向图? 图是一种基本的数据结构,在离散数学中有详细介绍过。 邻接矩阵? 图的邻接矩阵(Adjacency Matrix)存储方式是用两个数组来表示图。一个一维的数组存储图中顶点信息,一个二维数组(称为邻接矩阵)存储图中的边或弧的信息。 设图G有n个顶点,则邻接矩阵是一个n*n的方阵,定义为: 来看一个实例 注意索引问题!!! 图的遍历 图的遍历:从图的某个顶点出发,依次访问图中所有的顶点,每个顶点被访问一次且仅访问一次。 防止多次访问某一个顶点的思路:设置辅助数组visit 阅读详情

相关推荐

C++构造无向图,邻接矩阵,深度优先遍历,广度优先遍历

define MVNum 100 //最大顶点数//定义无向图邻接矩阵{//顶点表//邻接矩阵//图的当前定点数和边数};

qq_44757691的博客 6593

数据结构与算法:图

1.图的定义 2.图的存储结构(*) 3.图的遍历(**)(BFS+DFS) 4.生成树与最小生成树 (普里姆算法+克鲁斯卡尔算法) 5.应用 (迪杰斯特拉算法+拓扑排序)

C1hacker的博客 2329

java 邻接矩阵 深度优先算法_存储结构与邻接矩阵,深度优先和广度优先遍历及Java实现...

如果看完本篇博客任有不明白的地方,可以去看一下《大话数据结构》的7.4以及7.5,讲得比较易懂,不过是用C实现下面内容来自segmentfault存储结构要存储一个图,我们知道图既有结点,又有边,对于有权图来说,每条边上还带有权值。常用的图的存储结构主要有以下二种:邻接矩阵邻接表邻接矩阵我们知道,要表示结点,我们可以用一个一维数组来表示,然而对于结点和结点之间的关系,则无法简单地用一维数组来表示了...

weixin_36089954的博客 831

数据结构——图

数据结构—图 图的定义与基本术语 图:G=(V, E) V: 顶点(数据元素)的有穷非空集合 E: 边的有穷集合 有向图和无向图:前者边有方向,后者边无方向 ​ 完全图:任意两个点都有一条边相连 无向完全图:一张图中每条边都是无方向的;在无向完全图中;在无向完全图中:n个顶点,有n(n-1)/2条边 有向完全图:图中各边都有方向,且每两个顶点之间都有两条方向相反的边连接的图;在有向完全图中:n个顶点,有**n(n-1)**条边 稀疏图:有很少的边或弧的图 (e &l

weixin_43437546的博客 4388

C语言实现图之邻接表详解

邻接表是图的一种顺序存储和链式存储相结合的存储结构。它利用数组结合链表的结构来表示图中的顶点以及与顶点相关联的边。每一个顶点对应一个链表,链表中存储了所有与该顶点相邻的顶点,从而使得对于图的每个顶点,都能找到与它相邻接的所有顶点。这种数据结构特别适合表示稀疏图,因为它能够有效地节省空间,尤其是在边的数量远远小于顶点对总数的情况下。邻接矩阵是另一种图的表示方法,它使用一个二维数组来存储图中的边信息。如果顶点i到顶点j之间存在一条边,则矩阵中的元素为1,否则为0。

weixin_42360846的博客 1029

AURIX™ TC49x芯片手册中文分享(二)

主要内容为第一章、功能模块的特征

xibaofenqi的博客 1564

【数据结构】六、图:2.邻接矩阵、邻接表(有向图、无向图、带权图)

二、存储结构 ❗1.邻接矩阵 1.1无向图 ❗邻接矩阵-无向图代码-C 1.2有向图 ❗邻接矩阵-有向图代码-C 1.3带权图 1.4性能分析 1.5相乘 ❗2.邻接表 2.1无向图 2.2有向图 ❗邻接表-C 邻接矩阵VS邻接表 邻接矩阵 邻接表

关注:https://github.com/Suhan42 3938

【微知】关于GB200 NVL72服务器的一些信息?(36CPU72GPU;LPDDR5X 17T;HBM3e 13.5T;5代NVlink 1.8TB; 720P算力FP8;120Kw)

本文仅根据官网介绍分析,存在纰漏仅供参考。

技术札记 5399

图论基础与C++实现:从概念到邻接矩阵与邻接表

较少时,矩阵中存储了大量的0成为系数矩阵,比较浪费空间,并且要求两个节点之间的路径不是很好求。2. 如果边带有权值,并且两个节点之间是连通的,上图中的边的关系就用权值代替,如果两个。是该顶点的出度,也称出度表,要得到vi顶点的入度,必须检测其他所有顶点对应的边链。,图中的第k条边记作ek,ek = (vi,vj)或<vi,vj>。中,若从顶点v1到顶点v2有路径,则称顶点v1与顶点v2是连通的。因为图中既有节点,又有边(节点与节点之间的关系),因此,:在图G = (V, E)中,若。

2509_94101176的博客 604

穿透鼠标实现后台点击,适用于任何窗口!【后台鼠标】【风雪】

也许你就是被这标题吸引来的,呵呵!好久没发帖了,勾引一下大家的胃口,当然有的人已经猜出原理了!既然来了,都要把原理学回家,不然就没意思了!很多游戏现在都不支持后台消息鼠标,要实现真的不是简单的,什么注入dll啊,什么hook俺也学不懂,那就简简单单另辟蹊径了下面来讲讲原理吧(下面的玩玩可以,用于实际不现实,俺也不藏了,看到这么多人回复,良心过意不去,呵呵)首先,将要点击的窗口上面覆盖的所有窗...

weixin_34129145的博客 1万+

Minitab正交试验设计:从入门到精通的完整指南

本文提供了一份使用Minitab进行正交试验设计的完整指南。从正交试验省时省力的原理讲起,详细介绍了在Minitab中创建正交表、填入数据、执行分析(包括解读ANOVA和P值)以及寻找最优参数组合的全流程。文章旨在帮助读者,特别是工艺优化和研发人员,快速掌握这一高效工具,从而用最少的实验次数锁定关键影响因素,提升工作效率与成果。

weixin_29201313的博客 470

数据结构:无向图邻接矩阵转换为邻接表

无向图邻接矩阵转换为邻接表 代码如下(C): #include <stdio.h> #include<stdlib.h> #define MAXV 100 //以下定义邻接矩阵类型 typedef struct { int vexs[MAXV]; int arcs[MAXV]...

weixin_43893363的博客 1万+

在 Windows 系统下使用 VMware 安装 Ubuntu 24.04 LTS 系统

Ubuntu24.04桌面端官方下载:https://cn.ubuntu.com/download/desktop。

u014695938的博客 1万+

【C++】图的构造算法-邻接表表示法

结构分析: 算法思想: 输入总顶点数和总边数 建立顶点表,依次输入信息存于顶点表中,将每个顶点头节点的指针域初始化为NULL 创建邻接表,依次输入边所依附的两个顶点,确定两个顶点的下标 i 和 j ,建立边结点,使用头插法分别差入 vi 和 vj 对应的边链表的头部 存储表示: #define MaxInt 32767 // 极大值 #define MVNum 100 // 最大定点数 typedef int ArcType; // 边的权值类型 typedef char

Var-al 的博客 1418

Centos7.9使用kubeadm部署K8S集群

使用kubeadm部署一个k8s集群,单master+2worker节点。

lldhsds的专栏 1302

【JTAG】1500协议详解

随着集成电路的规模不断扩大,1149.1的板级测试无法满足要求越来越高的芯片测试需求。芯片规模变大后,测试需求不在是一次测试整片芯片,而是芯片分为好几个区域去测试,而1500协议正是对1149.1在该方面的一个补充即1149.1主要测试板级间的互连,而1500用来测试芯片内不同core之间的互连。IEEEStd1500已经为包含不同模块的集成电路(ICs)开发了一种可测试性设计标准方法。............

xuhe0206的博客 7039

有向图和无向图以及拓扑的复习

备注:大一学了图后,一段时间没用就还给老师了,如今重新复习一下,理解有误的地方请指教。 有向图和无向图的定义 1)关于有向图,百科中是这样描述的:一个有向图D是指一个有序三元组(V(D),A(D),ψD),其中ψD为关联函数,它使A(D)中的每一个元素(称为有向边或弧)对应于V(D)中的一个有序元素(称为顶点或点)对。 理解:如图D,如果e是D的一条边,而这时候存在这样的一个关系,ψD,有A,B...

legendaryhaha的博客 1万+

2026年沐曦集成电路数字IC笔试试卷带答案

本文摘要: 这是一份数字IC设计笔试模拟题,包含单选题、波形分析、多选题和代码设计题。重点考察ASIC设计流程(如逻辑综合将RTL转为门级网表)、时序分析(建立时间余量计算)、跨时钟域处理(格雷码应用)、复位机制、状态机设计等核心知识点。涉及沐曦特色考点如GPU架构(SIMT模型)、国产GPU芯片(曦云C系列)及MXMACA软件栈。代码题要求实现50%占空比三分频电路,综合考察Verilog设计能力。试题强调PPA优化、低功耗技术等工程实践要点,覆盖数字IC前端设计全流程核心内容。(149字)

Open 262

邻接表/图/DFS/BFS

目录存储形式 采用邻接表法创建无向网邻接表的特点 邻接矩阵与邻接表表示法的关系完整代码 顶点的结构 弧(边)的结点结构 图的结构定义 邻接表操作举例说明 邻接表的特点

m0_61548909的博客 1079

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

无向图的实现及简单算法

#include<iostream> //图论 无向图<---特殊化----有向图 //节点(vertex) 边(edge) 权! //交通运输 社交网络 互联网 脑区活动 //程序执行状态 #include<windows.h> #include<vector> #include<cassert> #include<ctime> ...

weixin_43398169的博客 1292

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

邻接表建立无向网

#include<iostream> using namespace std; #define max 20 typedef int elemtype; typedef struct arcnode { int adjvex;//弧指向结点位置 struct arcnode* nextarc;//指向下一个; elemtype m;//边信息域(权值等) }arcnode,*arcnodes; typedef struct vnode { int x;//数...

代码小生 1783

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

【数据结构】无向图(构造+遍历)

目录说在前面无向图相关概念图的表示构造广度优先遍历深度优先遍历Code 说在前面 实现语言:c++ vs版本:2017 无向图 相关概念 以下图为例 邻接矩阵 无向图,只要一半就行 邻接表 图的表示 在以下实现中使用了STL容器(vector、queue、stack等)以及智能指针(shared_ptr),相关概念自行了解。 在该示例中,图的存储使用邻接表。//边结构...

o0o 7961

图的邻接表和邻接矩阵

邻接表 一、邻接表 邻接表是图的一种链式存储结构。 邻接表中,对图中每个顶点建立一个单链表,第i个单链表中的结点表示依附于顶点Vi的边(对有向图是以顶点Vi为尾的弧)。 邻接表中的表结点和头结点结构: 表 结 点 adjvex nextarc

juryoo的专栏 8249

Floyd(弗洛伊德)算法(邻接矩阵与邻接表实现)——暴力求解多源点最短路

文章目录Floyd(弗洛伊德)算法(邻接矩阵与邻接表实现)——暴力求解多源点最短路简介思想与原理邻接矩阵解题模板邻接表解题模板 Floyd(弗洛伊德)算法(邻接矩阵与邻接表实现)——暴力求解多源点最短路 简介 Floyd算法又称为插点法,是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,可以正确处理有向图或无向图或负权(但不可存在负权回路)的最短路径问题,同时也被用于计算有向图的传递闭包。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 思想

pursuit的博客 7767

prim算法的邻接表和邻接矩阵实现

邻接矩阵版 const int maxn = 1000; const int INF = 100000; int n; //n为点数 int G[maxn][maxn]; ind d[maxn]; //d[i]表示顶点i到集合S的最短距离 bool vis[maxn] = {false}; int prim() { //初始化 fill(d, d + maxn, INF...

weixin_45367847的博客 923

【高阶数据结构】第三弹---图的存储与遍历详解:邻接表构建与邻接矩阵的BFS/DFS实现

图的存储结构:邻接表【边的结构,图的基本结构,图的创建,获取顶点下标,添加边,打印,测试一,测试二】;图的遍历:图的广度优先遍历,图的深度优先遍历~~~

小林熬夜学习编程的博客 2578
上一篇: 图的基本概念
下一篇: 有向图的邻接矩阵与邻接表详细实现
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

code_peak

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

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

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

打赏作者

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

抵扣说明:

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

余额充值