数据结构与算法(十一)-图(Graph)

已于 2022-11-24 17:42:06 修改
阅读量1.9k 收藏 8
点赞数 7
分类专栏： JavaScript数据结构与算法专栏 文章标签： 数据结构 算法 图论 前端 javascript
于 2022-01-17 14:45:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45792953/article/details/122539641
版权

文章目录

图结构(Graph)

一、图的介绍

1. 什么是图？

  • 图结构是一种与树结构有些相似的数据结构
  • 图论是数学的一个分支，并且，在数学中，树是图的一种
  • 图论以图为研究对象，研究顶点和边组成的图形的数学理论和方法
  • 主要的研究目的为：事物之间的联系，顶点代表事物，边代表两个事物间的关系

2.图的特点

  • 一组顶点：通常用 V （Vertex）表示顶点的集合
  • 一组边：通常用E（Edge）表示边的集合
    • 边是顶点和顶点之间的连线
    • 边可以是有向的，也可以是无向的。比如A----B表示无向，A —> B 表示有向

3. 图的常用术语：

  • 顶点：表示图中的一个节点
  • 边：表示顶点和顶点给之间的连线
  • 相邻顶点：由一条边连接在一起的顶点称为相邻顶点
  • 度：一个顶点的度是相邻顶点的数量
  • 路径：
    • **简单路径：**简单路径要求不包含重复的顶点
    • 回路：第一个顶点和最后一个顶点相同的路径称为回路
  • 无向图：图中的所有边都是没有方向的
  • 有向图：图中的所有边都是有方向的
  • **无权图：**无权图中的边没有任何权重意义
  • **带权图：**带权图中的边有一定的权重含义

4. 图的表示

4.1 邻接矩阵

表示图的常用方式为：邻接矩阵，如下图所示

  • 可以使用二维数组来表示邻接矩阵
  • 邻接矩阵让每个节点和一个整数相关联，该整数作为数组的下标值
  • 使用一个二维数组来表示顶点之间的连接

image-20200303213913574

邻接矩阵表示法示例，如上图所示：

  • 二维数组中的0表示没有连线，1表示有连线
    • 如：A[ 0 ] [ 3 ] = 1，表示 A 和 C 之间有连接
  • 邻接矩阵的对角线上的值都为0，表示A - A ，B - B，等自回路都没有连接（自己与自己之间没有连接）
  • 若为无向图，则邻接矩阵应为对角线上元素全为0的对称矩阵
邻接矩阵存在的问题：
  • 如果图是一个稀疏图，那么邻接矩阵中将存在大量的 0，造成存储空间的浪费
4.2 邻接表

另外一种表示图的常用方式为：邻接表，如下图所示

  • 邻接表由图中每个顶点以及和顶点相邻的顶点列表组成
  • 这个列表可用多种方式存储，比如：**数组/链表/字典（哈希表）**等都可以

image-20200303215312091

如上图所示：

  • 图中可清楚看到A与B、C、D相邻，假如要表示这些与A顶点相邻的顶点（边），可以通过将它们作为A的值（value）存入到对应的数组/链表/字典中
  • 之后，通过键（key）A，可以十分方便地取出对应的数据
邻接表的问题：
  • 邻接表可以简单地得出出度，即某一顶点指向其他顶点的个数；
  • 但是，邻接表计算入度（指向某一顶点的其他顶点的个数称为该顶点的入度）十分困难，此时需要构造逆邻接表才能有效计算入度

二、图结构的封装

这里我们采用邻接表的方式进行封装，使用之前封装过的字典结构（也可以理解为Map）来存储临近表

2.1 图类的创建

function Graph() {
  this.vertexes = []; // 存放顶点
  this.adList = new Dirtioany(); // 使用字典结构存放 边 信息
}

2.2 添加顶点和边

  • 我们需要创建一个数组对象vertexes存储图的顶点

  • 创建一个字典对象edges，来存储图的边，其中key为顶点值，value为存储key顶点相邻顶点的数组

  • 如下图所示

image-20200303235132868

// 1.添加顶点
Graph.prototype.addVertex = function (val) {
  this.vertexes.push(val); // 添加顶点
  this.adList.set(val, []); // 初始化顶点对应的边
};

// 2.添加边
Graph.prototype.addEdge = function (val1, val2) {
  // 因为边是相互存在的，所以需要存储关联两个顶点的信息
  // 这里实现的是无向图，所以不考虑方向的问题
  this.adList.get(val1).push(val2);
  this.adList.get(val2).push(val1);
};

2.3 实现toString()方法

为图类Graph添加toString方法，实现以邻接表的形式输出图中各顶点

// 3.toString方法
Graph.prototype.toString = function () {
  var resString = "";
  for (var i = 0; i < this.vertexes.length; i++) {
    resString += this.vertexes[i] + "->";
    var adList = this.adList.get(this.vertexes[i]);
    for (var j = 0; j < adList.length; j++) {
      resString += adList[j] + " ";
    }
    resString += "\n";
  }
  return resString;
};
测试代码
// 测试代码
let graph = new Graph();

// 添加顶点
let myVertexes = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < myVertexes.length; i++) {
  graph.addVertex(myVertexes[i]);
}

// 添加边
graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");

console.log(graph.toString());
// A->B C D
// B->A E F
// C->A D G
// D->A C G H
// E->B I
// F->B
// G->C D
// H->D
// I->E

2.4 图的遍历方式

图的遍历思想：
  • 图的遍历思想与树的遍历思想一样，意味着需要将图中所有的顶点都访问一遍，并且不能有重复的访问（上面的toString方法会重复访问）
遍历图的两种算法：
  • 广度优先搜索（Breadth - First Search，简称BFS）
  • 深度优先搜索（Depth - First Search，简称DFS）
  • 两种遍历算法都需要指定第一个被访问的顶点

为了记录顶点是否被访问过，这里使用三种颜色来表示它们的状态

  • 白色：表示该顶点还没有被访问过
  • 灰色：表示该顶点被访问过，但其相邻顶点并未完全被访问过
  • 黑色：表示该顶点被访问过，且其所有相邻顶点都被访问过

首先封装initializeColor方法将图中的所有顶点初始化为白色，代码实现如下：

/**
* 4.初始化顶点颜色
* 白色表示该顶点还没有被访问.
* 灰色表示该顶点被访问过, 但并未被探索过.
* 黑色表示该顶点被访问过且被完全探索过.
*/
Graph.prototype._initColors = function () {
  var colors = [];
  for (var i = 0; i < this.vertexes.length; i++) {
    colors[this.vertexes[i]] = "white";
  }
  return colors;
};

2.5 广度优先搜索(BFS)

思路：
  • 广度优先搜索算法会从指定的第一个顶点开始遍历图，先访问其所有的相邻顶点，就像一次访问图的一层
  • 也可以说是先宽后深地遍历图中的各个顶点

image-20200303233840691

实现思路：

基于队列可以简单地实现广度优先搜索算法：

  • 首先创建一个队列Q（尾部进，首部出）
  • 调用封装的initializeColor方法将所有顶点初始化为白色
  • 指定第一个顶点A，将A标注为灰色（被访问过的节点），并将A放入队列Q中
  • 循环遍历队列中的元素，只要队列Q非空，就执行以下操作
    • 先将灰色的A从Q的首部取出
    • 取出A后，将A的所有未被访问过（白色）的相邻顶点依次从队列Q的尾部加入队列，并变为灰色。以此保证，灰色的相邻顶点不重复加入队列
    • A的全部相邻节点加入Q后，A变为黑色，在下一次循环中被移除Q外
代码实现：
// 5.广度优先遍历
Graph.prototype.bfs = function (initV, handler) {
  var colors = this._initColors();
  var queue = new Queue();

  // 将定点放入队列
  queue.enqueue(initV);

  while (!queue.isEmpty()) {
    var qVal = queue.dequeue(); // 拿到队头的顶点
    var qAdj = this.adList.get(qVal); // 拿到队头对应的边
    // 将队头设置正在探索中 灰色
    colors[qVal] = "gray";

    // 将队头顶点相邻的边 全部拿出来遍历一遍，并加入到队列中
    for (var i = 0; i < qAdj.length; i++) {
      var vertexeValue = qAdj[i]; // 取出相邻顶点
      // 如果这个顶点是白色，说明没有被访问过
      if (colors[vertexeValue] === "white") {
        // 正在访问
        colors[vertexeValue] = "gray";
        // 将相邻顶点入队
        queue.enqueue(vertexeValue);
      }
    }

    // 代表该定点已经探索完毕，设置为黑色
    colors[qVal] = "black";

    // 输出
    handler && handler(qVal);
  }
};
测试代码
graph.bfs(graph.vertexes[0], function (value) {
  console.log(value); // A,B,C,D,E,F,G,H,I,
});
过程详解

下为指定的第一个顶点为A时的遍历过程：

  • 如 a 图所示，将在字典edges中取出的与A相邻的且未被访问过的白色顶点B、C、D放入队列que中并变为灰色，随后将A变为黑色并移出队列
  • 接着，如图 b 所示，将在字典edges中取出的与B相邻的且未被访问过的白色顶点E、F放入队列que中并变为灰色，随后将B变为黑色并移出队列

image-20200306144336380

  • 如 c 图所示，将在字典edges中取出的与C相邻的且未被访问过的白色顶点G（A，D也相邻不过已变为灰色，所以不加入队列）放入队列que中并变为灰色，随后将C变为黑色并移出队列
  • 接着，如图 d 所示，将在字典edges中取出的与D相邻的且未被访问过的白色顶点H放入队列que中并变为灰色，随后将D变为黑色并移出队列

image-20200306144427242

如此循环直到队列中元素为0，即所有顶点都变黑并移出队列后才停止，此时图中顶点已被全部遍历

为了更好的理解BFS，这里提供一份简版BFS，核心思路都是一样的

简版BFS
const graph = {
  0: [1, 2],
  1: [2],
  2: [0, 3],
  3: [3],
};

const bfs = (root) => {
  const visited = new Set(); // 用来存储，节点是否访问过
  visited.add(root);
  const q = [root]; //新建队列，根结点入队

  while (q.length) {
    let n = q.shift(); // 队列节点出队，拿到队头
    console.log(n); // 访问节点
    // 访问相邻节点，并入队
    graph[n]?.forEach((item) => {
      if (!visited.has(item)) { // 若没被访问过
        q.push(item); // 入队
        visited.add(item); // 表示已经访问过
      }
    });
  }
};

bfs(2); // 2 0 3 1

2.6深度优先搜索(DFS)

思路：
  • 深度优先搜索算法将会从指定的第一个顶点开始遍历图，沿着一条路径遍历直到该路径的最后一个顶点都被访问过为止
  • 接着沿原来路径回退并探索下一条路径，即先深后宽地遍历图中的各个顶点

image-20200304120355088

实现思路：
  • 可以使用栈结构来实现深度优先搜索算法
  • 深度优先搜索算法的遍历顺序与二叉搜索树中的先序遍历较为相似，同样可以使用递归来实现（递归的本质就是函数栈的调用）

基于递归实现深度优先搜索算法：定义dfs方法用于调用递归方法dfsVisit，定义dfsVisit方法用于递归访问图中的各个顶点。

这里实现dfs时，实现一个辅助函数dfsVisit，方便递归实现DFS。

在dfs方法中：

  • 首先，调用initializeColor方法将所有顶点初始化为白色
  • 然后，调用dfsVisit方法遍历图的顶点

在dfsVisit方法中：

  • 首先，将传入的指定节点v标注为灰色
  • 接着，处理顶点V
  • 然后，访问V的相邻顶点
  • 最后，将顶点v标注为黑色
代码实现：
// 6.深度优先遍历
Graph.prototype.dfs = function (initValue, handler) {
  var colors = this._initColors(); // 初始化顶点颜色
  this.dfsVisit(initValue, colors, handler); // 遍历
};

Graph.prototype.dfsVisit = function (v, colors, handler) {
  colors[v] = "gray"; // 访问中

  handler && handler(v); // 访问该顶点

  var vList = this.adList.get(v); // 获取相邻顶点
  for (var i = 0; i < vList.length; i++) {
    if (colors[vList[i]] === "white") {
      this.dfsVisit(vList[i], colors, handler); // 递归访问
    }
  }

  colors[v] = "black"; // 访问结束
};
测试代码
graph.dfs(graph.vertexes[0], function (value) {
  console.log(value); // A,B,E,I,F,C,D,G,H
});
过程详解

这里主要解释一下代码中的第3步操作：访问指定顶点的相邻顶点。

  • 以指定顶点A为例，先从储存顶点及其对应相邻顶点的字典对象edges中取出由顶点A的相邻顶点组成的数组

image-20200304155916036

  • 第一步：A顶点变为灰色，随后进入第一个for循环，遍历A白色的相邻顶点：B、C、D；在该for循环的第1次循环中（执行B），B顶点满足：colors == “white”，触发递归，重新调用该方法
  • 第二步：B顶点变为灰色，随后进入第二个for循环，遍历B白色的相邻顶点：E、F；在该for循环的第1次循环中（执行E），E顶点满足：colors == “white”，触发递归，重新调用该方法
  • 第三步：E顶点变为灰色，随后进入第三个for循环，遍历E白色的相邻顶点：I；在该for循环的第1次循环中（执行I），I顶点满足：colors == “white”，触发递归，重新调用该方法
  • 第四步：I顶点变为灰色，随后进入第四个for循环，由于顶点I的相邻顶点E不满足：colors == “white”，停止递归调用。过程如下图所示：

image-20200304160536187

  • 第五步：递归结束后一路向上返回，首先回到第三个for循环中继续执行其中的第2、3…次循环，每次循环的执行过程与上面的同理，直到递归再次结束后，再返回到第二个for循环中继续执行其中的第2、3…次循环…以此类推直到将图的所有顶点访问完为止。

下图为遍历图中各顶点的完整过程：

  • 发现表示访问了该顶点，状态变为灰色；
  • 探索表示既访问了该顶点，也访问了该顶点的全部相邻顶点，状态变为黑色；
  • 由于在顶点变为灰色后就调用了处理函数handler，所以handler方法的输出顺序为发现顶点的顺序即：A、B、E、I、F、C、D、G、H 。

image-20200304154745646

为了更好的理解DFS，这里也提供一份简版DFS

简版DFS
const graph = {
  0: [1, 2],
  1: [2],
  2: [0, 3],
  3: [3],
};

let set = new Set();
const dfs = (n) => {
  console.log(n);
  set.add(n);
  graph[n]?.forEach((item) => {
    if (!set.has(item)) {
      dfs(item);
    }
  });
};

dfs(2); // 2 0 1 3

2.7 完整代码

const Dirtioany = require("./dict");
const Queue = require("../03-队列结构/01-queue");

function Graph() {
  this.vertexes = []; // 存放顶点
  this.adList = new Dirtioany(); // 使用字典结构存放 边 信息

  // 1.添加顶点
  Graph.prototype.addVertex = function (val) {
    this.vertexes.push(val); // 添加顶点
    this.adList.set(val, []); // 初始化顶点对应的边
  };

  // 2.添加边
  Graph.prototype.addEdge = function (val1, val2) {
    // 因为边是相互存在的，所以需要存储关联两个顶点的信息
    // 这里实现的是无向图，所以不考虑方向的问题
    this.adList.get(val1).push(val2);
    this.adList.get(val2).push(val1);
  };

  // 3.toString方法
  Graph.prototype.toString = function () {
    var resString = "";
    for (var i = 0; i < this.vertexes.length; i++) {
      resString += this.vertexes[i] + "->";
      var adList = this.adList.get(this.vertexes[i]);
      for (var j = 0; j < adList.length; j++) {
        resString += adList[j] + " ";
      }
      resString += "\n";
    }
    return resString;
  };

  /**
   * 4.初始化顶点颜色
   * 白色表示该顶点还没有被访问.
   * 灰色表示该顶点被访问过, 但并未被探索过.
   * 黑色表示该顶点被访问过且被完全探索过.
   */
  Graph.prototype._initColors = function () {
    var colors = [];
    for (var i = 0; i < this.vertexes.length; i++) {
      colors[this.vertexes[i]] = "white";
    }
    return colors;
  };

  // 5.广度优先遍历
  Graph.prototype.bfs = function (initV, handler) {
    var colors = this._initColors();
    var queue = new Queue();

    // 将定点放入队列
    queue.enqueue(initV);

    while (!queue.isEmpty()) {
      var qVal = queue.dequeue(); // 拿到队头的顶点
      var qAdj = this.adList.get(qVal); // 拿到队头对应的边
      // 将队头设置正在探索中 灰色
      colors[qVal] = "gray";

      // 将队头顶点相邻的边 全部拿出来遍历一遍，并加入到队列中
      for (var i = 0; i < qAdj.length; i++) {
        var vertexeValue = qAdj[i]; // 取出相邻顶点
        // 如果这个顶点是白色，说明没有被访问过
        if (colors[vertexeValue] === "white") {
          // 正在访问
          colors[vertexeValue] = "gray";
          // 将相邻顶点入队
          queue.enqueue(vertexeValue);
        }
      }

      // 代表该定点已经探索完毕，设置为黑色
      colors[qVal] = "black";

      // 输出
      handler && handler(qVal);
    }
  };

  // 6.深度优先遍历
  Graph.prototype.dfs = function (initValue, handler) {
    var colors = this._initColors(); // 初始化顶点颜色
    this.dfsVisit(initValue, colors, handler); // 遍历
  };

  Graph.prototype.dfsVisit = function (v, colors, handler) {
    colors[v] = "gray"; // 访问中

    handler && handler(v); // 访问该顶点

    var vList = this.adList.get(v); // 获取相邻顶点
    for (var i = 0; i < vList.length; i++) {
      if (colors[vList[i]] === "white") {
        this.dfsVisit(vList[i], colors, handler); // 递归访问
      }
    }

    colors[v] = "black"; // 访问结束
  };
}

// 测试代码
let graph = new Graph();

// 添加顶点
let myVertexes = ["A", "B", "C", "D", "E", "F", "G", "H", "I"];
for (let i = 0; i < myVertexes.length; i++) {
  graph.addVertex(myVertexes[i]);
}

// 添加边
graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("A", "D");
graph.addEdge("C", "D");
graph.addEdge("C", "G");
graph.addEdge("D", "G");
graph.addEdge("D", "H");
graph.addEdge("B", "E");
graph.addEdge("B", "F");
graph.addEdge("E", "I");

console.log(graph.toString());
// A->B C D
// B->A E F
// C->A D G
// D->A C G H
// E->B I
// F->B
// G->C D
// H->D
// I->E

graph.bfs(graph.vertexes[0], function (value) {
  console.log(value); // A,B,C,D,E,F,G,H,I,
});

graph.dfs(graph.vertexes[0], function (value) {
  console.log(value); // A,B,E,I,F,C,D,G,H
});

往期精彩文章

一个爱编程的男孩
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
图论基础
CCPP Blog
07-18 7558
图概述 图(Graph)是一种比线性结构和树形结构都要复杂的数据结构。简单讲，图是由表示数据元素的的集合V和表示数据之间关系的集合E组成。其中，数据元素常称作顶点(vertex)，数据之间的关系常称作边(edge)。故图可记为G=<V,E>，其中V是顶点的有穷非空集合，E是边的集合。在图中顶点的前驱和后继是不设限制的，因此图描述的是一种网状关系。 无向图 若边是无序的或者说是无向的，则称此图是无向图。若无向图中有边(v1,v2)(无向图中边用圆括号表示)，则显然(v2,v1)和(v1,v2)是同一条边。
数据结构与算法之图结构
热门推荐
努力让自己发光，对的人才能迎着光而来
09-09 1万+
图的基本概念 图的存储结构及实现 邻接矩阵 邻接表 图的遍历方式及实现 广度优先搜索 深度优先搜索基本概念 代码实现 遍历
数据结构与算法（四）图形结构篇
qq_25928447的博客
09-04 4137
图结构在我们的生活中实际上是非常常见的，其中最显著的就是我们的地图了，比如我的家乡重庆：可以看到，地图盘根错节，错综复杂，不同的道路相互连接，我们可以自由地从这些道路通过，从一个地点到达另一个地点。当然除了地图，我们的计算机网络、你的人际关系网等等，这些都可以用图结构来表示。图结构也是整个数据结构中比较难的一部分，而这一章，我们将探讨图结构的性质与应用。
图的基本结构分类
m0_65213200的博客
09-20 1109
图
图（Graph）详解 - 数据结构
qq_61939403的博客
12-21 5992
图及其最短路径算法详解
数据结构，图结构(笔记)
weixin_60547084的博客
01-17 869
1. 什么是图？ 图结构是一种与树结构相似的数据结构 图论是数学的一个分支，并且在数学的概念上，树也是图的一种 他以图为研究对象，研究的顶点和边组成的图形 主要研究事物之间的关系，顶点代表事物，边代表两个事物之间的关系 2. 图的应用场景 我们要知道树结构有很多应用场景，比如公司的架构、家族的关系等 图结构的话，有人与人之间的关系网，人就代表顶点，人与人之间的关系就代表边 科学家们在观察人与人之间关系网的时候，还发现了六度空间理论 3. 六度空间理论 你和任何一个陌生人之间所间隔的人不会超过六个
Python数据结构与算法之图结构（Graph）实例分析
09-21
主要介绍了Python数据结构与算法之图结构（Graph）,结合实例形式分析了图结构的概念、原理、使用方法及相关操作技巧,需要的朋友可以参考下
C#，图论与图算法，图（Graph）的数据结构设计与源代码
最新发布
04-09
C#，图论与图算法，图（Graph）的数据结构设计与源代码 图（Graph）是一组对象的图示，其中一些对象对通过链接连接。互连对象由称为顶点的点表示，连接顶点的链接称为边。 形式上，图是一对集（V，E），其中V是顶点...
graph-library：图形的数据结构和算法
02-05
图Java库图形数据结构和算法。执照Copyright (C) 2017 MINDORKS NEXTGEN PRIVATE LIMITEDLicensed under the Apache License, Version 2.0 (the "License");you may not use this file except in compliance with ...
Python数据结构课程 数据结构与算法Python语言描述 配套源代码集合 共9个章节.rar
02-26
【完整源码列表】 chapter_01_Introduction chapter_03_Linear_List chapter_04_String chapter_05_Stack_and_Queue chapter_06_Binary_tree chapter_07_Graph chapter_08_Dict_and_Set chapter_09_Sort
【数据结构与算法】图(Graph)【详解】
DreamSun的博客
03-25 6895
图(Graph)是由顶点的有穷非空集合V ( G ) 和顶点之间边的集合E ( G )组成，通常表示为: G = ( V , E ) ，其中，G表示个图，V 是图G中顶点的集合，E是图G中边的集合。若V = { v 1 , v 2 , . . . , v n } ，则用∣ V ∣表示图G中顶点的个数，也称图G的阶，E = { ( u , v ) ∣ u ∈ V , v ∈ V } ，用∣ E ∣表示图G中边的条数。注意:线性表可以是空表，树可以是空树，但图不可以是空图。
【JS】数据结构之图结构
qq_45677671的博客
11-30 1324
图是由顶点和边构成，所以图里面要存储的图形结构信息，无非是存储图的顶点和图的边。顶点可以之间通过数组去存储，那边该通过什么存储呢？欧拉开创了新的学科：图论（数学的一个分支）
JavaScript算法05-从树中删除边的最小分数
zztjl的博客
11-10 264
JavaScript、leetcode刷题、从树中删除边最小的分数
2019LeetCode第 12 场双周赛
Onwaier的博客
11-03 494
5097. 力扣排行榜 题目描述 新一轮的「力扣杯」编程大赛即将启动，为了动态显示参赛者的得分数据，需要设计一个排行榜 Leaderboard。 请你帮忙来设计这个 Leaderboard 类，使得它有如下 3 个函数： addScore(playerId, score)： 假如参赛者已经在排行榜上，就给他的当前得分增加 score 点分值并更新排行。 假如该参赛者不在排行榜上，就把他添加到榜单上...
算法数据结构基础——图（Graph）
白话机器学习
06-06 836
图（Graph）：由顶点的非空有限集合 $V$ （由 $n > 0$ 个顶点组成）与边的集合 $E$（顶点之间的关系）构成的结构。其形式化定义为 $G = (V, E)$。顶点（Vertex）：图中的数据元素通常称为顶点，在下面的示意图中我们使用圆圈来表示顶点。边（Edge）：图中两个数据元素之间的关联关系通常称为边，在下面的示意图中我们使用连接两个顶点之间的线段来表示边。
评估图中重要结点的一些指标
weixin_43915129的博客
03-22 432
原文出版。
数据结构和算法-13.图
u014215131的博客
03-24 104
1. 图的基本概念 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱 当我们需要表示多对多的关系时，就用到了图 两个节点之间的连接称为边(edge)，节点也可以称为顶点(vertex) 带权图：也叫网 2. 图的表示方式 两种：二维数组表示（邻接矩阵）；链表表示（邻接表） 2.1 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1…n个点 2.2 邻接表 邻接矩阵需要为每个顶点都分配n个边的空间，有很多边是不存在
数据结构 | 图 | prim算法
qq_41914142的博客
09-08 417
prim基本思想 普里姆方法的基本思想是：在图中任取一个顶点K作为开始点，令U={k}，W=V-U，其中V为图中所有顶点集，然后找一个顶点在U中，另一个顶点在W中的边中最短的一条，找到后，将该边作为最小生成树的树边保存起来，并将该边顶点全部加入U集合中，并从W中删去这些顶点，然后重新调整U中顶点到W中顶点的距离, 使之保持最小，再重复此过程，直到W为空集止。 代码如下： public class PrimeTest { ////图，可以这样认为：图的任意两个顶点之间都有边，两顶点无法到达的，可以认为他们之
数据结构学习笔记——图的基本知识
小宇y的博客
08-11 2187
图是由一个非空的顶点集合V（顶点集）和一个描述顶点之间关系——边的有限非空集合E（边集）所组成的一种数据结构，记为G=（V，E），其中图的顶点集V不一定为空，而图的边集E可以为空。
数据结构与算法c++笔记
08-31
很高兴回答你关于数据结构与算法的问题！以下是一些关于C语言中数据结构和算法的笔记： 1. 数据结构： - 数组（Array）：一组相同类型的元素按顺序存储在连续的内存空间中。 - 链表（Linked List）：由节点（Node）组成，每个节点包含数据和指向下一个节点的指针。 - 栈（Stack）：先进后出（LIFO）的数据结构，可以使用数组或链表实现。 - 队列（Queue）：先进先出（FIFO）的数据结构，可以使用数组或链表实现。 - 树（Tree）：由节点和边组成的非线性数据结构，常见的有二叉树、二叉搜索树等。 - 图（Graph）：由节点和边组成的非线性数据结构，常用于表示网络、关系等。 2. 算法： - 排序算法：常见的有冒泡排序、插入排序、选择排序、快速排序、归并排序等。 - 查找算法：常见的有线性查找、二分查找等。 - 哈希算法：通过哈希函数将数据映射到哈希表中，实现高效的查找和插入操作。 - 图算法：常见的有深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、Floyd-Warshall等）等。 这只是数据结构与算法的一小部分内容，还有很多其他知识点和算法可以学习。希望这些笔记对你有所帮助！如果你有任何问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一个爱编程的男孩

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

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

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

打赏作者

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

抵扣说明：

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

余额充值