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 = 0; 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 = 0; 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 = 0; i < this.vertices.length; i++) {
            d[this.vertices[i]] = 0;
            pred[this.vertices[i]] = null;
        }
        while (!queue.isEmpty()) {
            let u = queue.dequeue(),
                neighbors = this.adjList.get(u);
            color[u] = 'grey';
            for (let i = 0; i < neighbors.length; i++) {
                let w = neighbors[i];
                if (color[w] === 'white') {
                    color[w] = 'grey';
                    d[w] = d[u] + 1;
                    pred[w] = u;
                    queue.enqueue(w);
                }
            }
            color[u] = 'black';
        }
        return {
            distances: d,
            predecessors: pred
        }
    }
    public toString() {
        let s = '';
        for (let i = 0; i < this.vertices.length; i++) {
            s += this.vertices[i] + ' -> ';
            let neighbors = this.adjList.get(this.vertices[i]);
            for (var j = 0; j < neighbors.length; j++) {
                s += neighbors[j] + ' ';
            }
            s += '
';
        }
        return s;
    }
}
var graph = new Graph();
var myVertices = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']; //{7} 
for (var i = 0; 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[0], printNode);

var shortestPathA = graph.BFS(myVertices[0]);
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 = 0; 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 = 0; 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 = 0; i < this.vertices.length; i++) {
            d[this.vertices[i]] = 0;
            pred[this.vertices[i]] = null;
        }
        while (!queue.isEmpty()) {
            var u = queue.dequeue(), neighbors = this.adjList.get(u);
            color[u] = 'grey';
            for (var i_2 = 0; i_2 < neighbors.length; i_2++) {
                var w = neighbors[i_2];
                if (color[w] === 'white') {
                    color[w] = 'grey';
                    d[w] = d[u] + 1;
                    pred[w] = u;
                    queue.enqueue(w);
                }
            }
            color[u] = 'black';
        }
        return {
            distances: d,
            predecessors: pred
        };
    };
    Graph.prototype.toString = function () {
        var s = '';
        for (var i_3 = 0; i_3 < this.vertices.length; i_3++) {
            s += this.vertices[i_3] + ' -> ';
            var neighbors = this.adjList.get(this.vertices[i_3]);
            for (var j = 0; j < neighbors.length; j++) {
                s += neighbors[j] + ' ';
            }
            s += '
';
        }
        return s;
    };
    return Graph;
}());