JavaScript 图

TypeScript方式实现源码

// 图的遍历算法
// 算  法         数据结构     描  述
// 深度优先搜索    栈          通过将顶点存入栈中，顶点是沿着路径被探索的，存在新的相
// 邻顶点就去访问
// 广度优先搜索    队列        通过将顶点存入队列中，最先入队列的顶点先被探索
// 当要标注已经访问过的顶点时，我们用三种颜色来反映它们的状态。
//  白色：表示该顶点还没有被访问。
//  灰色：表示该顶点被访问过，但并未被探索过。
//  黑色：表示该顶点被访问过且被完全探索过。
// 广度优先搜索算法会从指定的第一个顶点开始遍历图， 先访问其所有的相邻点， 就像一次访
// 问图的一层

 class Graph {
     vertices = [];
     adjList = new Dictionary();
     public addVertex(v) {
         this.vertices.push(v);
         this.adjList.set(v, []);
     }
     public addEdge(v, w) {
         this.adjList.get(v).push(w);
         this.adjList.get(w).push(v);
     }
     public initializeColor() {
         let color = [], length = this.vertices.length;
         for (var i = ; i < length; i++) {
             color[this.vertices[i]] = 'white';
         }
         return color;
     }
     /**
      * 宽度优先搜索
      * @param v
      * @param callback
      */
     public bfs(v, callback) {
         let color = this.initializeColor(),
             queue = new Queue();
         queue.enqueue(v);
         while (!queue.isEmpty()) {
             let u = queue.dequeue(),
                 neighbors = this.adjList.get(u);
             color[u] = 'grey';
             for (let i = ; i < neighbors.length; i++) {
                 let w = neighbors[i];
                 if (color[w] === 'white') {
                     color[w] = 'grey';
                     queue.enqueue(w);
                 }
             }
             color[u] = 'black';
             if (callback) {
                 callback(u);
             }
         }
     }
     /**
      * 寻找最短路径
      * @param v
      */
     public BFS(v) {
         let color = this.initializeColor(),
             queue = new Queue(),
             d = [],
             pred = [];
         queue.enqueue(v);
         for (var i = ; i < this.vertices.length; i++) {
             d[this.vertices[i]] = ;
             pred[this.vertices[i]] = null;
         }
         while (!queue.isEmpty()) {
             let u = queue.dequeue(),
                 neighbors = this.adjList.get(u);
             color[u] = 'grey';
             for (let i = ; i < neighbors.length; i++) {
                 let w = neighbors[i];
                 if (color[w] === 'white') {
                     color[w] = 'grey';
                     d[w] = d[u] + ;
                     pred[w] = u;
                     queue.enqueue(w);
                 }
             }
             color[u] = 'black';
         }
         return {
             distances: d,
             predecessors: pred
         }
     }
     public toString() {
         let s = '';
         for (let i = ; i < this.vertices.length; i++) {
             s += this.vertices[i] + ' -> ';
             let neighbors = this.adjList.get(this.vertices[i]);
             for (var j = ; j < neighbors.length; j++) {
                 s += neighbors[j] + ' ';
             }
             s += '\n';
         }
         return s;
     }
 }
 var graph = new Graph();
 var myVertices = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']; //{7}
 for (var i = ; i < myVertices.length; i++) { //{8}
     graph.addVertex(myVertices[i]);
 }
 graph.addEdge('A', 'B'); //{9}
 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());
 
 function printNode(value) {
     console.log('Visited vertex:' + value);
 }
 graph.bfs(myVertices[], printNode);
 
 var shortestPathA = graph.BFS(myVertices[]);
 console.log(shortestPathA);

JavaScript方式实现源码

 var Graph = (function () {
     function Graph() {
         this.vertices = [];
         this.adjList = new Dictionary();
     }
     Graph.prototype.addVertex = function (v) {
         this.vertices.push(v);
         this.adjList.set(v, []);
     };
     Graph.prototype.addEdge = function (v, w) {
         this.adjList.get(v).push(w);
         this.adjList.get(w).push(v);
     };
     Graph.prototype.initializeColor = function () {
         var color = [], length = this.vertices.length;
         for (var i = ; i < length; i++) {
             color[this.vertices[i]] = 'white';
         }
         return color;
     };
     /**
      * 宽度优先搜索
      * @param v
      * @param callback
      */
     Graph.prototype.bfs = function (v, callback) {
         var color = this.initializeColor(), queue = new Queue();
         queue.enqueue(v);
         while (!queue.isEmpty()) {
             var u = queue.dequeue(), neighbors = this.adjList.get(u);
             color[u] = 'grey';
             for (var i_1 = ; i_1 < neighbors.length; i_1++) {
                 var w = neighbors[i_1];
                 if (color[w] === 'white') {
                     color[w] = 'grey';
                     queue.enqueue(w);
                 }
             }
             color[u] = 'black';
             if (callback) {
                 callback(u);
             }
         }
     };
     /**
      * 寻找最短路径
      * @param v
      */
     Graph.prototype.BFS = function (v) {
         var color = this.initializeColor(), queue = new Queue(), d = [], pred = [];
         queue.enqueue(v);
         for (var i = ; i < this.vertices.length; i++) {
             d[this.vertices[i]] = ;
             pred[this.vertices[i]] = null;
         }
         while (!queue.isEmpty()) {
             var u = queue.dequeue(), neighbors = this.adjList.get(u);
             color[u] = 'grey';
             for (var i_2 = ; i_2 < neighbors.length; i_2++) {
                 var w = neighbors[i_2];
                 if (color[w] === 'white') {
                     color[w] = 'grey';
                     d[w] = d[u] + ;
                     pred[w] = u;
                     queue.enqueue(w);
                 }
             }
             color[u] = 'black';
         }
         return {
             distances: d,
             predecessors: pred
         };
     };
     Graph.prototype.toString = function () {
         var s = '';
         for (var i_3 = ; i_3 < this.vertices.length; i_3++) {
             s += this.vertices[i_3] + ' -> ';
             var neighbors = this.adjList.get(this.vertices[i_3]);
             for (var j = ; j < neighbors.length; j++) {
                 s += neighbors[j] + ' ';
             }
             s += '\n';
         }
         return s;
     };
     return Graph;
 }());