跨越静态，以JavaScript构筑动态数据结构——图

2024-01-17 13:01:16

图：JavaScript中的复杂关系建模

什么是图？

图是一种强大的数据结构，它允许我们表示复杂的关系。在计算机科学中，图是一个由一系列节点（或顶点）和连接这些节点的边构成的集合。节点可以表示对象，如人、地点或事件，而边表示节点之间的关系。

图的实现方式

图有多种不同的实现方式。最常见的两种是邻接表和邻接矩阵。在邻接表中，每个节点都有一个指向与它相连的边列表。在邻接矩阵中，节点之间的关系存储在一个二维数组中，其中每个元素表示两个节点之间的权重。

JavaScript中的图

JavaScript是一种流行的编程语言，可以用来实现各种数据结构，包括图。最简单的方法是使用对象。每个节点可以表示为一个对象，该对象具有一个唯一ID和一个指向与它相连的边列表。每条边也可以表示为一个对象，该对象具有一个起点、一个终点和一个权重。

操作图

一旦图被表示为对象，就可以使用各种算法来操作它。例如，深度优先搜索（DFS）和广度优先搜索（BFS）可以用来遍历图。最小生成树（MST）算法可以用来找到连接图中所有节点的最低成本路径。

图的应用

图在许多不同的应用中都很重要。它们可以用来表示社交网络、路线规划、数据结构之间的关系等。图也被用来解决许多不同的问题，如最短路径问题、旅行商问题和着色问题。

图的代码示例

下面是一个使用JavaScript实现图的示例代码：

class Graph {
  constructor() {
    this.vertices = {};
  }

  addVertex(vertex) {
    this.vertices[vertex] = [];
  }

  addEdge(vertex1, vertex2) {
    this.vertices[vertex1].push(vertex2);
    this.vertices[vertex2].push(vertex1);
  }

  depthFirstSearch(vertex) {
    const visited = {};
    const stack = [vertex];

    while (stack.length) {
      const currentVertex = stack.pop();

      if (!visited[currentVertex]) {
        visited[currentVertex] = true;
        console.log(currentVertex);

        for (const neighbor of this.vertices[currentVertex]) {
          if (!visited[neighbor]) {
            stack.push(neighbor);
          }
        }
      }
    }
  }

  breadthFirstSearch(vertex) {
    const visited = {};
    const queue = [vertex];

    while (queue.length) {
      const currentVertex = queue.shift();

      if (!visited[currentVertex]) {
        visited[currentVertex] = true;
        console.log(currentVertex);

        for (const neighbor of this.vertices[currentVertex]) {
          if (!visited[neighbor]) {
            queue.push(neighbor);
          }
        }
      }
    }
  }

  minimumSpanningTree(vertex) {
    const visited = {};
    const edges = [];
    const queue = [vertex];

    while (queue.length) {
      const currentVertex = queue.shift();

      if (!visited[currentVertex]) {
        visited[currentVertex] = true;

        for (const neighbor of this.vertices[currentVertex]) {
          if (!visited[neighbor]) {
            const edge = {
              start: currentVertex,
              end: neighbor,
              weight: this.vertices[currentVertex][neighbor],
            };

            edges.push(edge);
            queue.push(neighbor);
          }
        }
      }
    }

    edges.sort((a, b) => a.weight - b.weight);

    const minimumSpanningTree = [];

    for (const edge of edges) {
      if (!this.hasCycle(minimumSpanningTree, edge)) {
        minimumSpanningTree.push(edge);
      }
    }

    return minimumSpanningTree;
  }

  hasCycle(edges, edge) {
    const visited = {};

    const depthFirstSearch = (vertex) => {
      if (visited[vertex]) {
        return true;
      }

      visited[vertex] = true;

      for (const neighbor of this.vertices[vertex]) {
        if (depthFirstSearch(neighbor)) {
          return true;
        }
      }

      return false;
    };

    return depthFirstSearch(edge.start);
  }
}

const graph = new Graph();
graph.addVertex('A');
graph.addVertex('B');
graph.addVertex('C');
graph.addVertex('D');
graph.addVertex('E');
graph.addVertex('F');
graph.addVertex('G');

graph.addEdge('A', 'B');
graph.addEdge('A', 'C');
graph.addEdge('B', 'D');
graph.addEdge('C', 'D');
graph.addEdge('C', 'E');
graph.addEdge('D', 'E');
graph.addEdge('D', 'F');
graph.addEdge('E', 'F');
graph.addEdge('F', 'G');

console.log('Depth First Search:');
graph.depthFirstSearch('A');

console.log('Breadth First Search:');
graph.breadthFirstSearch('A');

const minimumSpanningTree = graph.minimumSpanningTree('A');
console.log('Minimum Spanning Tree:');
console.log(minimumSpanningTree);