Neighbor table

Add each vertex first, then join the Edge

Queue

var Queue = (function () {

var item = new Weakmap ();

Class queue{

Constructor () {

Item.set (this,[]);

}

Enqueue (ele) {

var ls = item.get (this);

Ls.push (ele);

}

Dequeue () {

var ls = item.get (this);

return Ls.shift ();

}

Size () {

var ls = item.get (this);

return ls.length;

}

Front () {

var ls = item.get (this);

return ls[0];

}

IsEmpty () {

var ls = item.get (this);

return!ls.length;

}

Print () {

var ls = item.get (this);

for (var i = 0; i < ls.length; i++) {

Console.log (' ${ls[i]} ');

}

}

}

return Queue;

})();

Depth-First Search

Breadth First Search

function Graph () {

var vertices = []; Store all the vertices

var adjlist = {}; Stores adjacent vertices of all vertices

This.addvertex = function (v) {

if (!adjlist[v]) {

Vertices.push (v);

ADJLIST[V] = [];

}else{

throw new Error ("The vertex already exists");

}

};

var initializecolor = function () {

var color = {};

for (var i = 0; i < vertices.length; i++) {

Color[vertices[i]] = ' white ';

}

return color;

}

This.addedge = function (v,w) {

if (Adjlist[v] && adjlist[w]) {

Adjlist[v].push (w);

Adjlist[w].push (v);

}else{

throw new Error ("link non-existent vertex");

}

};

this.tostring = function () {

var s = ';

for (var i=0; i<vertices.length; i++) {//{10}

s + = Vertices[i] + ' + ';

var neighbors = adjlist[vertices[i]]; {11}

for (var j=0; j<neighbors.length; J + +) {//{12}

s + = neighbors[j] + ';

}

s + = ' \ n '; {13}

}

return s;

};

This.print = function () {

Console.log (This.tostring ());

};

Breadth-first search, find each point

Search for neighboring points for each point

1, initialize, all the vertex states are white, that is, no traversal to

2, through the point, get an array of adjacent points, traverse the adjacent points

3. If the neighboring point is white, it becomes gray. and join the queue, into the next loop

THIS.BFS = function (v,callback) {

var color = Initializecolor ();

Queue = new Queue ();

Queue.enqueue (v);

while (!queue.isempty ()) {

var u = queue.dequeue ();

Neighbors = Adjlist[u];

Color[u] = ' grey ';

for (var i = 0; i < neighbors.length; i++) {

var w = neighbors[i];

if (color[w] = = = ' White ') {

COLOR[W] = ' grey ';

Queue.enqueue (w);

}

}

Color[u] = "BLACK";

if (callback) {

Callback (U);

}

}

};

Breadth-first algorithm to calculate the distance of each vertex

This. BFS = function (v) {

var color = Initializecolor ();

Queue = new Queue ();

Queue.enqueue (v);

d = []; Distance List

Pred = []; Forward Point

for (var i=0; i<vertices.length; i++) {

D[vertices[i]] = 0;

Pred[vertices[i]] = null;

}

while (!queue.isempty ()) {

var u = queue.dequeue ();

Neighbors = Adjlist[u];

Color[u] = ' grey ';

for (var i = 0; i < neighbors.length; i++) {

var 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

}

}

This.getpath = function (u) {

//Print Shortest path

//The adjacent point before backtracking

var shortestpath = this. BFS (U);

var Fromvertex = vertices[0];

for (var i=1; i<vertices.length; i++) {

var Tovertex = vertices[i],

Path = [];

for (var V=tovertex; v!== Fromvertex;

V=shortestpath.predecessors[v]) {

Path.push (v);

}

Path.push (Fromvertex);

var s = path.join ("-");

Console.log (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 ');

GRAPH.BFS ("A", function (Cnode) {

Console.log (Cnode);

});

Console.log (graph. BFS ("A"));

Graph.getpath (' A ');

/*

If you want to calculate the shortest path in a weighted graph (for example, the shortest distance between cities) breadth-first search may not be appropriate.

* The Dijkstra algorithm solves the single source shortest path problem. The Bellman-ford algorithm solves a negative Benquan value.

Single source shortest path problem. A * search algorithm solves the problem of finding the shortest path between a pair of vertices, which uses the rule of thumb to speed up search

The cable process. The Floyd-warshall algorithm solves the problem of finding the shortest path between all vertex pairs.

*

* */

JS graph data structure processing----neighbor list, breadth first search, minimum path