程序员经验分享-hwhale

【数据结构】图的实现

2023-11-10

图

1.图的基本概念

图是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)，其中：

  • 顶点集合V = {x|x属于某个数据对象集}是有穷非空集合；
  • E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫
    做边的集合。
  • (x, y)表示x到y的一条双向通路，即(x, y)是无方向的；Path(x, y)表示从x到y的一条单向通路，即Path(x, y)是有方向的。

图相关的概念

  • 顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或<vi，vj>。
  • 有向图和无向图：在有向图中，顶点对<x, y>是有序的，顶点对<x，y>称为顶点x到顶点y的一条边(弧)，<x, y>和<y, x>是两条不同的边，比如下图G3和G4为有向图；在无向图中，顶点对(x, y)是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)是同一条边，比如下图G1和G2为无向图。注意：无向边(x, y)等于有向边<x, y>和<y, x>。

image-20221130233546990

完全图

  • 无向完全图：即图中每两个顶点都有边。在有n个顶点的无向图中，若有n * (n-1)/2条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图 。
  • 有向完全图：在n个顶点的有向图中，若有n * (n-1)条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图。

顶点的度

  • 顶点的度：顶点v的度是指与它相关联的边的条数，记作deg(v)。在有向图中，顶点的度等于该顶点的入度与出度之和。在无向图中顶点的度等于该顶点的入度和出度，即dev(v)=indev(v) = outdev(v)。

路径

  • 路径：在图G = (V， E)中，若从顶点vi出发有一组边使其可到达顶点vj，则称顶点vi到顶点vj的顶点序列为从顶点vi到顶点vj的路径
  • 路径长度：对于不带权的图，一条路径的路径长度是指该路径上的边的条数；**对于带权的图，一条路径的路径长度是指该路径上各个边权值的总和。 **

image-20221130235744933

子图

子图：设图G = {V, E}和图G1 = {V1，E1}，若V1属于V且E1属于E，则称G1是G的子图。

image-20221130235927698

**连通图：**在无向图中，若从顶点v1到顶点v2有路径，则称顶点v1与顶点v2是连通的。如果图中任
意一对顶点都是连通的，则称此图为连通图。

**强连通图：**在有向图中，若在每一对顶点vi和vj之间都存在一条从vi到vj的路径，也存在一条从vj
到vi的路径，则称此图是强连通图

生成树：一个连通图的最小连通子图称作该图的生成树。有n个顶点的连通图的生成树有n个顶点
和n-1条边。

2.图的存储结构

图的存储方式主要有两种，一种叫邻接矩阵，一种叫做邻接表。

3.邻接矩阵

因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一
个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。

无向图

image-20221201000759319

有向图

image-20221201000814567

注意：

无向图的邻接矩阵是一个对称图；第i行(列)元素之和，就是顶点i的度。有向图的邻接矩阵则不一
定是对称的，第i行(列)元素之后就是顶点i 的出(入)度。

带权图

对于有权值的图：边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。

image-20221201001552642

3.1邻接矩阵的优缺点

优点：

  • 能够快速知道两个顶点是否连通。

缺点：

  • 顶点比较多，边比较少时，矩阵中存储了大量的0成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。
3.2邻接矩阵的实现

基本接口框架：包括构造函数，边的添加函数，返回下标等

namespace matrix
{
    template <class V, class W, W MAX_W = INT64_MAX, bool Direction = false>
    class Graph
    {
        struct edge
        {
            size_t _srci; //起点下标
            size_t _dsti; //指向下标
            W _w;         //权值
            edge(size_t srci, size_t dsti, W w) : _srci(srci), _dsti(dsti), _w(w)
            {
            }
            bool operator>(const edge &e) const
            {
                return _w > e._w;
            }
        };

        typedef Graph<V, W, MAX_W, Direction> self;

    public:
        Graph() = default;
        //构造函数
        Graph(const V *v, size_t n)
        {
            _vertexs.reserve(n);
            for (size_t i = 0; i < n; i++)
            {
                _vertexs.push_back(v[i]);
                _indexmap[v[i]] = i;
            }
            //为存储边的矩阵开辟空间
            _matrix.resize(n);
            for (size_t i = 0; i < _matrix.size(); i++)
            {
                _matrix[i].resize(n, MAX_W);
            }
        }
        
        //返回顶点的下标
        size_t GetVertexIndex(const V &v);
        
        //边的添加函数
        void addedge(const V &src, const V &dst, const W &w);
        
        
        //打印邻接矩阵函数
        void Print();
     private:
        unordered_map<V, int> _indexmap; //记录顶点和下标的映射关系
        vector<V> _vertexs;              // 顶点集合的集合
        vector<vector<W>> _matrix;       // 存储边集合的矩阵
    };
}

返回顶点的下标

顶点和顶点下标的映射关系，由一个Hash表存储。可以直接访问Hash表得到顶点的下标

//获取顶点的下标API
size_t GetVertexIndex(const V &v)
{
    auto it = _indexmap.find(v);
    if (it != _indexmap.end())
    {
        return _indexmap[v];
    }
    else
    {
        std::cout << "不存在这样的节点" << std::endl;
        return -1;
    }
}

添加边API

添加边时，需要判断图是否为有向图。如果是一个无向图，那么天需要添加两次。

void _addedge(size_t srci, size_t dsti, const W &w)
{
    _matrix[srci][dsti] = w;
    if (Direction == false)
    {
        _matrix[dsti][srci] = w;
    }
}
void addedge(const V &src, const V &dst, const W &w)
{
    size_t srci = GetVertexIndex(src);
    size_t dsti = GetVertexIndex(dst);
    assert(srci != -1);
    assert(dsti != -1);
    _addedge(srci, dsti, w);
}

打印临界矩阵

如果两个顶点直接没有边，就使用*表示

void Print()
{
    //先打印顶点
    for (int i = 0; i < _vertexs.size(); i++)
    {
        cout << "[" << i << "]"
             << "->" << _vertexs[i]<<endl;
    }
    cout << endl;
    // 横下标
    cout << "  ";
    for (size_t i = 0; i < _vertexs.size(); ++i)
    {
        // cout << i << " ";
        printf("%4d", i);
    }
    cout << endl;
    for (size_t i = 0; i < _matrix.size(); ++i)
    {
        cout << i << " "; // 竖下标
        for (size_t j = 0; j < _matrix[i].size(); ++j)
        {
            // cout << _matrix[i][j] << " ";
            if (_matrix[i][j] == MAX_W)
            {
                // cout << "* ";
                printf("%4c", '*');
            }
            else
            {
                // cout << _matrix[i][j] << " ";
                printf("%4d", _matrix[i][j]);
            }
        }
        cout << endl;
    }
    cout << endl;
}

接口测试结果

void test_matrix(){
    matrix::Graph<char, int, INT64_MAX, true> g("0123", 4);
    g.addedge('0', '1', 1);
    g.addedge('0', '3', 4);
    g.addedge('1', '3', 2);
    g.addedge('1', '2', 9);
    g.addedge('2', '3', 8);
    g.addedge('2', '1', 5);
    g.addedge('2', '0', 3);
    g.addedge('3', '2', 6);
    g.Print();
}
int main()
{
    test_matrix();
    return 0;
}

image-20221201013812819

4.邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。

无向图邻接表

image-20221201130808813

**注意：**无向图中同一条边在邻接表中出现了两次。如果想知道顶点vi的度，只需要知道顶点vi边链表集合中结点的数目即可。

有向图邻接表

image-20221201140055317

**注意：**有向图中每条边在邻接表中只出现一次，与顶点vi对应的邻接表所含结点的个数，就是该顶点的出度，也称出度表，要得到vi顶点的入度，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst取值是i。

4.1邻接表的实现

基本接口框架：包括构造函数，边的添加函数，返回下标等；

namespace link_table
{

    template <class V, class W, W MAX_W = INT64_MAX, bool Direction = false>
    class Graph
    {
        typedef Graph<V, W, MAX_W, Direction> self;
        struct edge
        {
            //由于是链表，起点就是当前点，所以一般都省略
            // int _srci;
            size_t _dsti; //目标点
            W _w;        //权值

            //用一个链表将于该顶点相连的顶点连接起来
            edge *_next;
            edge(size_t dsti, const W& w)
                : _dsti(dsti), _w(w), _next(nullptr)
            {
            }
        };

    public:
        //构造函数
        Graph() = default;
        Graph(const V *a, size_t n)
        {
            _vertexs.reserve(n);
            //添加顶点
            for (size_t i = 0; i < n; i++)
            {
                _vertexs.push_back(a[i]);
                _indexmap[a[i]] = i;
            }
            _tables.resize(n, nullptr);
        }

        //获取顶点的下标
        size_t GetVertexIndex(const V &v);

        //添加边的API
        void addedge(const V &src, const V &dst, const W &w);
        
	   //打印接口API
        void Print();

    private:
        unordered_map<V, int> _indexmap; //记录顶点和下标的映射关系
        vector<V> _vertexs;              // 顶点集合的集合
        vector<edge *> _tables;          //邻接表
    };
};

获取顶点的下标

顶点和顶点下标的映射关系，由一个Hash表存储。可以直接访问Hash表得到顶点的下标。

//获取顶点的下标
size_t GetVertexIndex(const V &v)
{
    auto it = _indexmap.find(v);
    if (it != _indexmap.end())
    {
        return _indexmap[v];
    }
    else
    {
        std::cout << "不存在这样的节点" << std::endl;
        return -1;
    }
}

添加边

//添加边
void addedge(const V &src, const V &dst, const W &w)
{
    size_t srci = GetVertexIndex(src);
    size_t dsti = GetVertexIndex(dst);
    //头插的方式
    edge *head = _tables[srci];
    edge *eg = new edge(dsti, w);
    eg->_next = head;
    _tables[srci] = eg;
    //如果是无向图
    if (Direction == false)
    {
        edge *eg = new edge(srci, w);
        eg->_next = _tables[dsti];
        _tables[dsti] = eg;
    }
}

打印邻接表

void Print()
{
    //打印顶点
    for (size_t i = 0; i < _vertexs.size(); i++)
    {
        cout << "[" << i << "]"
             << "->" << _vertexs[i] << endl;
    }

    //打印边
    for (size_t i = 0; i < _tables.size(); i++)
    {
        cout << _vertexs[i] << "[ " << i << "]->";
        edge *cur = _tables[i];
        while (cur)
        {
            cout << "[" << _vertexs[cur->_dsti] << ":" << cur->_dsti << ":" << cur->_w << "]->";
            cur = cur->_next;
        }
        cout << "nullptr" << endl;
    }
}

测试邻接表的实现

void test_table()
{
    string a[] = {"张三", "李四", "王五", "赵六"};
    link_table::Graph<string, int> g1(a, 4);
    g1.addedge("张三", "李四", 100);
    g1.addedge("张三", "王五", 200);
    g1.addedge("王五", "赵六", 30);
    g1.Print();
}
int main()
{
    test_table();
    return 0;
}

image-20221201151708559

5.图的遍历

图的遍历有两种方式，一种是广度优先遍历(BFS),另一种是深度优先遍历(DFS)。下面以邻接矩阵为例，实现图的广度优先遍历和深度优先遍历。

5.1广度优先遍历

比如现在你需要找你的钥匙，有三个抽屉，东西在哪个抽屉不清楚，现在要将其找到，广度优先遍历的做法是：

  • 先将三个抽屉打开，在三个抽屉的最外层找一遍
  • 依次打开三个抽屉的第二层，再找一遍。
  • 如果没有找到，依次打开第三个抽屉的第三层，再找一边…
  • 重复上面的操作，直到找到钥匙…

image-20221201152535817

邻接矩阵的广度优先遍历实现

思路：像树的层序遍历一样，借助一个队列实现广度遍历。

image-20221201153122462

但是可能会出现重复遍历的问题，造成死循环。

解决办法：使用一个标记数组，记录顶点是否已经被遍历。如果顶点已经被遍历，则不再入队列。

image-20221201154220153

void BFS(const V &src)
{
    size_t srci = GetVertexIndex(src);
    //遍历队列
    queue<int> q;
    //标记数组
    vector<bool> visited(_vertexs.size(), false);
    q.push(srci);
    visited[srci] = true;
    int n = _vertexs.size();
    int num = 0;
    int size = 1;
    while (!q.empty())
    {
        cout << "第" << num << "层：" << endl;
        for (int i = 0; i < size; i++)
        {
            int front = q.front();
            q.pop();
            cout << front << ":" << _vertexs[front] << " ";
            for (int i = 0; i < n; i++)
            {
                if (_matrix[front][i] != MAX_W && !visited[i])
                {
                    q.push(i);
                    visited[i] = true;
                }
            }
            cout << endl;
        }
        num++;
        size = q.size();
    }
    cout << endl;
}

测试程序

void test_matrix()
{
    matrix::Graph<char, int, INT64_MAX, false> g("ABCDEFGHI", 9);
    g.addedge('A','B',1);
    g.addedge('A','C',1);
    g.addedge('A','D',1);
    g.addedge('B','E',1);
    g.addedge('B','C',1);
    g.addedge('C','F',1);
    g.addedge('D','F',1);
    g.addedge('E','G',1);
    g.addedge('F','H',1);
    g.addedge('H','I',1);
    g.Print();
    g.BFS('A');
}

image-20221201161456928

美团的面试题：六度人脉理论

image-20221201163507488

这个题的思路需要用到广度优先遍历，每一层就是小点的一度人脉。

void test_matrix()
{
    string name[]={"小美","小团","小卓","小越","小诚","小信"};
    matrix::Graph<string, int> g(name, 6);
    g.addedge("小美","小团",1);
    g.addedge("小美","小卓",1);
    g.addedge("小美","小诚",1);
    g.addedge("小团","小诚",1);
    g.addedge("小卓","小越",1);
    g.addedge("小卓","小信",1);
    g.addedge("小信","小越",1);
    g.BFS("小美");
}

image-20221201164456383

5.2深度优先遍历

image-20221201163100588

深度优先遍历的遍历顺序与顶点插入顺序有关，不同的插入顺序可能有不同的遍历结果。

image-20221201163312306

void _DFS(size_t srci, vector<bool> &visited)
{
    cout << srci << ":" << _vertexs[srci] << " ";
    visited[srci] = true;
    for (int i = 0; i < _vertexs.size(); i++)
    {
        if (_matrix[srci][i] != MAX_W && !visited[i])
        {
            _DFS(i, visited);
        }
    }
}
void DFS(const V &src)
{
    size_t srci = GetVertexIndex(src);
    vector<bool> visited(_vertexs.size(), false);
    _DFS(srci, visited);
    cout << endl;
}

测试结果

void test_matrix()
{
    matrix::Graph<char, int, INT64_MAX, false> g("ABCDEFGHI", 9);
    g.addedge('A','B',1);
    g.addedge('A','C',1);
    g.addedge('A','D',1);
    g.addedge('B','E',1);
    g.addedge('B','C',1);
    g.addedge('C','F',1);
    g.addedge('D','F',1);
    g.addedge('E','G',1);
    g.addedge('F','H',1);
    g.addedge('H','I',1);
    g.Print();
    g.DFS('A');
}

image-20221201163417801

5.3如何遍历不连通的图？

image-20221201164644666

比如上面的图：

在进行图的遍历的时候，我们使用了一个遍历数组记录该顶点是否被遍历。

如何遍历不连通的图：在bool数组中寻找还没有遍历过的点进行遍历。

以上面的图为例：

void test_matrix()
{

    matrix::Graph<char, int> g("ABCDEFGHI",9);
    g.addedge('A','B',1);
    g.addedge('A','D',1);
    g.addedge('B','E',1);
    g.addedge('E','G',1);
    g.addedge('C','F',1);
    g.addedge('F','H',1);
    g.addedge('H','I',1);
    g.BFS('A');
}

广度优先遍历

void _BFS(size_t srci, vector<bool> &visited)
{
    //遍历队列
    queue<int> q;
    q.push(srci);
    visited[srci] = true;
    int n = _vertexs.size();
    int num = 0;
    int size = 1;
    while (!q.empty())
    {
        cout << "第" << num << "层：" << endl;
        for (int i = 0; i < size; i++)
        {
            int front = q.front();
            q.pop();
            cout << front << ":" << _vertexs[front] << " ";
            for (int i = 0; i < n; i++)
            {
                if (_matrix[front][i] != MAX_W && !visited[i])
                {
                    q.push(i);
                    visited[i] = true;
                }
            }
            cout << endl;
        }
        num++;
        size = q.size();
    }
    cout << endl;
}

void BFS(const V &src)
{

    //标记数组
    vector<bool> visited(_vertexs.size(), false);
    size_t srci = GetVertexIndex(src);
    _BFS(srci, visited);
    for (int i = 0; i < visited.size(); i++)
    {
        if (!visited[i])
        {
            cout << endl;
            _BFS(i, visited);
        }
    }
}

image-20221201170049423

深度优先遍历

void _DFS(size_t srci, vector<bool> &visited)
{
    cout << srci << ":" << _vertexs[srci] << " ";
    visited[srci] = true;
    for (int i = 0; i < _vertexs.size(); i++)
    {
        if (_matrix[srci][i] != MAX_W && !visited[i])
        {
            _DFS(i, visited);
        }
    }
}
//非连通图的遍历
void DFS(const V &src)
{
    size_t srci = GetVertexIndex(src);
    vector<bool> visited(_vertexs.size(), false);
    _DFS(srci, visited);
    for (int i = 0; i < visited.size(); i++)
    {
        if (!visited[i])
        {
            cout << endl;
            _DFS(i, visited);
        }
    }
    cout << endl;
}

image-20221201170400122

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构笔记

数据结构

图论

算法

【数据结构】图的实现 的相关文章

随机推荐

  • HBuilder云打包ios证书申请流程

    我们在hbuilderx打ios正式包的时候 需要私钥证书p12文件 和描述文件mobileprovision文件 但是生成这两个工具需要使用mac电脑 这对于我们使用windows电脑的同学们望而却步 幸好 我们中国有在线的生成ios证书

  • TypeScript声明全局类型

    背景 定义TS类型声明文件xxx d ts 文件中的类型 在外部文件使用时 理论上不需要引入文件 直接使用就行 而自定义的api d ts中的类型无法在外部使用 第一次api d ts定义方式 api d ts文件 export inter

  • 安装配置MySQL数据库服务器-多版本（简单详细，一学就会）

    目录 引言 一 5 6 51数据库服务器下载 二 8 1 0最新版数据库服务器下载 引言 个人认为MySQl数据库目前推荐的两个版本系列为5 6 51和8 系列 至于我们为什么要下载两个版本呢 是因为官方在数据库下载的结构上有所改变 5 系

  • VS2019 C++ 学习笔记三（列表框和组合框）

    一 新建一个工程 二 增加组合框和列表框 三 更改组合框和列表框的ID ID分别为 IDC COMBO COMM IDC LIST DEMO IDC EDIT INPUT 四 给列表框添加变量

  • Centos7挂载2T以下及2T以上硬盘

    一 挂载2T以下的硬盘 1 列出所有已挂载磁盘 df h 2 查看磁盘信息 从上图可以看到有一块600多g的硬盘没有挂载 dev sdb 3 硬盘分区 使用fdisk工具对磁盘分区 fdisk dev sdb 依次输入 n p 1 回车 回

  • Spring自动装配byName和byType的区别

    文章目录 前言 一 byName 二 byType 1 Class类型 2 Autowired 总结 前言 开发的时候一直用 Autowired和 Resource注解实现自动装配 但是一直不明白byType这个装配方式是什么 研究才明白这

  • 校园网如何用路由器开WiFi

    本文虽不是首创 但也可以说是全网最清楚有效的教程 本文主要针对非网络专业学生而写 因此写得会非常详细 第一步 首先准备一台电脑 一部手机 手机安装掌上大学 各个地域说法不一样 用你们能登上宽带账号的那个软件 手机的作用是登录账号 电脑的作用

  • 移植Qt5.6

    交叉编译工具 arm linux gcc 4 4 3内核 linux 4 12 0 使用移植linux 4 12到JZ2440里的linux 4 12 按照2 4 制作补丁内容获取内核 补丁下载地址 https pan baidu com

  • svn密码工具

    前言 忘记svn密码了 怎么办 下载工具运行 下载 官方地址http www leapbeyond com ric TSvnPD 教程 1 点击下载包 2 下载下来是这个 3 双击运行 到此结束

  • 【STM32】定时器中断原理及操作

    目录 时钟的选择及分频 定时器中断有关的寄存器 定时器中断有关的库函数 1 时钟使能函数 RCC APB1PeriphClockCmd 2 定时器初始化函数 TIM TimeBaseInit 3 定时器中断使能 选择函数 TIM ITCon

  • 车辆路径问题

    车辆路径问题 提示 这里可以添加系列文章的所有文章的目录 目录需要自己手动添加 利用Python和Gurobi求解VRPSPDTW 考虑需求动态变化的共享单车调度问题研究 提示 写完文章后 目录可以自动生成 如何生成可参考右边的帮助文档 文

  • 用python实现二分查找（折半查找）

    文章目录 一 算法简介 二 算法思路 三 具体编码 一 算法简介 折半查找又叫二分查找 要求线性表必须采用顺序存储结构 而且表中元素按关键字有序排列 升序或者降序 时间复杂度 O log2n 每次循环都会舍弃一半的查找空间 空间复杂度 O

  • 利用读时建模等数据分析能力，实现网络安全态势感知的落地

    摘要 本文提出一种基于鸿鹄数据平台的网络安全态势感知系统 系统借助鸿鹄数据平台读时建模 时序处理 数据搜索等高效灵活的超大数据存储和分析处理能力 支持海量大数据存储 分类 统计到数据分析 关联 预测 判断的网络安全态势感知能力需求 以安全大

  • HttpRequest中常见的四种ContentType

    HTTP 1 1 协议规定的 HTTP 请求方法有 OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT 这几种 其中 POST 一般用来向服务端提交数据 本文主要讨论 POST 提交数据的几种方式

  • python中的GIL详解

    python中的GIL详解 参考Python GIL 锁简述 GIL是什么 首先需要明确的一点是GIL并不是Python的特性 它是在实现Python解析器 CPython 时所引入的一个概念 就好比C 是一套语言 语法 标准 但是可以用不

  • mysql启动失败：mysql服务无法启动 服务没有报告任何错误 解决方法

    1 一开始无法启动时因为mysql安装目录下我没有Data文件夹 而我的my ini文件通过查找默认在C ProgramData MySQL MYSQL Server 8 0于是参考mysql无法启动 服务没有报任何错误 进行了如下部分更改

  • 游戏开发物理引擎PhysX研究系列：学习链接

    参考 基础介绍 原 译 physX phsyX3 3 4官方文档物理引擎基本概念和例子介绍 如何使用官方自带的demo Nvidia PhysX 学习文档2 Snippets PhysX 物理引擎研究 一 源码编译 在 Net平台使用Phy

  • 码云使用pull request出现无法合并

    在使用码云的时候 常常会因为各种各样的原因而出现冲突这里就来讲一下如何解决 再做第一步之前先把你要上传的文件copy出来然后解决冲突后再把他们扔进去上传 那第一步先来查看我们的源 git remote v 那么很明显我这里有一个origin

  • 非root用户-elastic-stack日志收集系统的规划及部署

    架构图 192 168 140 17 ELK 1 4核 8G 250G centos7 8 ES1 kibana 192 168 140 18 ELK 2 4核 8G 250G centos7 8 ES2 192 168 140 19 EL

  • 【数据结构】图的实现

    文章目录 图 1 图的基本概念 2 图的存储结构 3 邻接矩阵 3 1邻接矩阵的优缺点 3 2邻接矩阵的实现 4 邻接表 4 1邻接表的实现 5 图的遍历 5 1广度优先遍历 5 2深度优先遍历 5 3如何遍历不连通的图 图 1 图的基本概

热门标签