【数据结构】图的实现

最新推荐文章于 2024-04-21 16:05:25 发布
最新推荐文章于 2024-04-21 16:05:25 发布
阅读量1.2k 收藏 3
点赞数 2
分类专栏： 数据结构笔记 文章标签： 数据结构 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53893431/article/details/128135395
版权

文章目录

图

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

影中人lx
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java graph结构_数据结构—图(Graph)的入门概念、存储结构、遍历方式以及Java代码的实现...
weixin_33478575的博客
02-19 3453
本文首先介绍了图的入门概念，然后介绍了图的邻接矩阵和邻接表两种存储结构、以及深度优先遍历和广度优先遍历的两种遍历方式，最后提供了Java代码的实现。图，算作一种比较复杂的数据结构，因此建议有一定数据结构基础的人再来学习！1 图的定义和相关概念定义图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。图在...
【数据结构】图
colorfulshark
03-27 372
【1】定义图（Graph）是一种非线性数据结构 任意的两个元素都可能相关，即图中任一元素可以有若干个直接前驱和直接后继，属于网状结构类型。 树是图的特例——有向无环图 【2】有向图（Digraph）设 Vi、Vj为图中的两个顶点，若关系< Vi,Vj >存在方向性，称之为有向图，记作< Vi,Vj > ，Vi为弧尾，Vj为弧头 【3】无向图（Undigraph）设Vi、Vj为图中的两个顶点，若关系
数据结构课程设计源码 图子系统
03-21
数据结构课程设计源码 图子系统 详细注释+图形界面操作 简单易操作
数据结构（C语言）-图子系统（实验）
czh2637750821的博客
03-16 3409
图子系统一、实验目的二、实验内容三、实验步骤四、参考程序5、运行结果 一、实验目的 （1)掌握图邻接矩阵的存储方法。 （2)掌握图的深度优先遍历的基本思想。 （3)掌握图的广度优先遍历的基本思想。 （4）掌握普利姆算法与克鲁斯卡尔算法 （5）掌握利用迪杰斯特拉算法求最短路径 二、实验内容 （1）编写为从键盘输入的数据建立邻接矩阵存储 （2）编写图的深度优先遍历算法 （3）编写图的广度优先遍历算法 （4）编写普利姆算法与克鲁斯卡尔算法 （5）编写迪杰斯特拉算法求最短路径 三、实验步骤 （1）输入并调试程序 （
数据结构——图的基本概念及其存储结构和遍历的实现（用C++语言实现）
2303_79953471的博客
04-21 900
根据大学教材数据结构（C语言版 严蔚敏 李冬梅 吴伟民编著）写的一篇第六章——图的学习笔记并用代码实现,详细概括了图的数据结构特点并用代码实现
数据结构与算法——图的实现
m0_68963624的博客
05-06 429
【代码】数据结构与算法——图的实现。
图的简单实现
遗落在树梢的风筝
03-18 229
基本介绍 当需要表示多对多的关系时，就要用到图 图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表） 图的遍历方式：深度优先遍历；广度优先遍历 深度优先遍历 广度优先遍历 两种遍历方式的比较 代码实现 package graph; import java.util.ArrayList; import java.util.Arrays; /** * * @Description 图 * @author ningqian QQ:2587658527 * @version
数据结构C语言实现代码.zip
10-22
`data-structures-master`很可能是一个包含各种数据结构实现的源代码仓库，而`2`可能是另一个相关的代码文件或子目录。下面我们将详细探讨这两个部分可能涵盖的数据结构及其C语言实现。 1. **线性数据结构**：包括...
简单数据结构实现.zip
最新发布
06-17
在“简单数据结构实现.zip”这个压缩包中，我们很可能会找到关于常见数据结构及其算法实现的详细资料，这对于学习和理解数据结构至关重要。 首先，我们要了解数据结构的基本类型。常见的数据结构包括数组、链表、栈...
数据结构配套代码c实现
12-03
该书深入浅出地讲解了各种数据结构，包括数组、链表、栈、队列、树、图等，并提供了详细的C语言实现。这个压缩包中的代码正是基于这本书的内容，但可能包含更多的示例和习题，旨在帮助读者更深入地理解和应用这些...
数据结构算法实现严蔚敏教材
04-13
在C++中实现这些数据结构和算法时，可以利用面向对象的特性，定义类来封装数据和操作，同时利用STL（Standard Template Library）提供的容器和算法，如vector、list、set、map等，它们已经实现了多种基础数据结构，...
C++实现图 - 01 图的概述及实现
Newin2020的博客
05-24 2996
写在前面： 前面我们讲的数据结构都是针对于一对一或一对多的情形，如果涉及到多对多的复杂情况就要用到我们接下来讲解的图了，这一讲我们重点讲解邻接表、邻接矩阵、十字链表以及邻接多重表的代码实现。如果已经对图的概念比较熟悉的小伙伴，可以拉到下面看相关的代码实现。 图的概述 图 G 是由两个集合 V 和 E 组成，记为 G = （V，E），其中 V 代表顶点，E 代表边，如下图（这里涉及到有向边和无向边，下面会展开讲）。 图的相关概念 简单图 在图结构中，若不存在顶点到其自身的边，且同⼀条边没有重复出现，则称这.
图的实现
hunhunee666的博客
09-13 386
说明 只保留顶点的索引号，而不需要知道任何与顶点相关的信息。因此，使用一个数组表示点集。 使用一个数组mark来记录每个顶点是否被访问过，用来实现图的遍历，最小生成树算法和最短路径算法。 图的邻接矩阵表示法中，用一个二维数组matrix表示边的权重。如果边不存在，则权重为0。如果边存在，则权重大于0。 图的邻接表表示法中，有一个长度为|V|的数组，数组中第 i 个元素存储指向顶点 i 的所有边构成的链表。链表的节点存储边的信息，由于边的起点已知，只需要存储边的终点和权重即可。 邻接矩阵表示法 Gr
java实现图
闵浮龙的博客
09-24 1274
一、图基本介绍 1、为什么要有图 前面我们学了线性表和树 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时，这里我们就用到了图。 2、图的举例说明 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图: 3、图的常用概念 顶点(vertex) 边(edge) 路径 无向图(下...
数据结构--图总结（八大算法）
qq_41409979的博客
05-12 2324
图总结 本章主要讲诉一些图的经典算法以及容易忘记的概念便于以后进行复习。 文章目录图总结一、易混淆的概念二、经典算法1.DFS与BFS2.读入数据总结 一、易混淆的概念 边，弧：顶点到顶点之间有向叫做边，无向叫做弧。 完全图,连通图：任意两个顶点之间都有边是完全图，任意两个顶点之间存在路劲是连通图（如果是有向的话叫强连通图）。 生成树,有向树,生成深林：无向联通图中如果只有n个顶点n-1条边（没有环）叫生成树，有向图中只有一个顶点入度为0，其余顶点入度为1叫做有向树。一个有向图由若干个有向树构成生成深林
数据结构子系统
m0_67828940的博客
12-20 532
switch嵌套
图的定义、表示、基本操作的实现、遍历
derbi123123的博客
02-09 980
1.什么是图？ 表示多对多的关系。包含： （1）一组顶点：V（vertex） 在线性表中我们称数据对象为元素；在树中称之为结点；在图中就称之为顶点。线性表和树可以有没有数据对象的空表和空树，但空图必须至少有一个顶点，边可以没有。 （2）一组边：E（edge） （3）边还可能有权重：代表一些必要信息。当然，顶点也可能有数据。 图的相关术语： 顶点的度：指与该顶点相连的边的个数，又分为入度和出度，入...
实验七 图的深度优先遍历
m0_51308557的博客
12-22 3702
图的邻接表表示法定义及基本操作的实现。邻接表(Adjacency List)是图的一种顺序存储与链式存储结合的存储方法。邻接表表示法类似于树的孩子链表表示法。就是对于图G 中的每个顶点vi，将所有邻接于vi 的顶点vj 链成一个单链表，这个单链表就称为顶点vi 的邻接表，再将所有点的邻接表表头放到数组中，就构成了图的邻接表

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

影中人lx

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

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

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

打赏作者

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

抵扣说明：

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

余额充值