Graph Algorithm

Sorts/TopologicalSort.js

@@ -0,0 +1,59 @@
+function TopologicalSorter() {
+ var graph = {},
+ isVisitedNode,
+ finishTimeCount,
+ finishingTimeList,
+ nextNode;
+
+ this.addOrder = function (nodeA, nodeB) {
+ nodeA = String(nodeA);
+ nodeB = String(nodeB);
+ graph[nodeA] = graph[nodeA] || [];
+ graph[nodeA].push(nodeB);
+ }
+
+ this.sortAndGetOrderedItems = function () {
+ isVisitedNode = Object.create(null);
+ finishTimeCount = 0;
+ finishingTimeList = [];
+
+ for (var node in graph) {
+ if (graph.hasOwnProperty(node) && !isVisitedNode[node]) {
+ dfsTraverse(node);
+ }
+ }
+
+ finishingTimeList.sort(function (item1, item2) {
+ return item1.finishTime > item2.finishTime ? -1 : 1;
+ });
+
+ return finishingTimeList.map(function (value) { return value.node })
+ }
+
+ function dfsTraverse(node) {
+ isVisitedNode[node] = true;
+ if (graph[node]) {
+ for (var i = 0; i < graph[node].length; i++) {
+ nextNode = graph[node][i];
+ if (isVisitedNode[nextNode]) continue;
+ dfsTraverse(nextNode);
+ }
+ }
+
+ finishingTimeList.push({
+ node: node,
+ finishTime: ++finishTimeCount
+ });
+ }
+}
+
+
+/* TEST */
+var topoSorter = new TopologicalSorter();
+topoSorter.addOrder(5, 2);
+topoSorter.addOrder(5, 0);
+topoSorter.addOrder(4, 0);
+topoSorter.addOrder(4, 1);
+topoSorter.addOrder(2, 3);
+topoSorter.addOrder(3, 1);
+console.log(topoSorter.sortAndGetOrderedItems());

maths/DijkstraSmallestPath.js

@@ -0,0 +1,118 @@
+// starting at s
+function solve(graph, s) {
+ var solutions = {};
+ solutions[s] = [];
+ solutions[s].dist = 0;
+
+ while(true) {
+ var p = null;
+ var neighbor = null;
+ var dist = Infinity;
+
+
+ for(var n in solutions) {
+ if(!solutions[n])
+ continue
+ var ndist = solutions[n].dist;
+ var adj = graph[n];
+
+ for(var a in adj) {
+
+ if(solutions[a])
+ continue;
+
+ var d = adj[a] + ndist;
+ if(d < dist) {
+
+ p = solutions[n];
+ neighbor = a;
+ dist = d;
+ }
+ }
+ }
+
+ //no more solutions
+ if(dist === Infinity) {
+ break;
+ }
+
+ //extend parent's solution path
+ solutions[neighbor] = p.concat(neighbor);
+ //extend parent's cost
+ solutions[neighbor].dist = dist;
+ }
+
+ return solutions;
+}
+//create graph
+var graph = {};
+
+var layout = {
+ 'R': ['2'],
+ '2': ['3','4'],
+ '3': ['4','6','13'],
+ '4': ['5','8'],
+ '5': ['7','11'],
+ '6': ['13','15'],
+ '7': ['10'],
+ '8': ['11','13'],
+ '9': ['14'],
+ '10': [],
+ '11': ['12'],
+ '12': [],
+ '13': ['14'],
+ '14': [],
+ '15': []
+}
+
+//convert uni-directional to bi-directional graph
+// var graph = {
+// a: {e:1, b:1, g:3},
+// b: {a:1, c:1},
+// c: {b:1, d:1},
+// d: {c:1, e:1},
+// e: {d:1, a:1},
+// f: {g:1, h:1},
+// g: {a:3, f:1},
+// h: {f:1}
+// };
+
+for(var id in layout) {
+ if(!graph[id])
+ graph[id] = {};
+ layout[id].forEach(function(aid) {
+ graph[id][aid] = 1;
+ if(!graph[aid])
+ graph[aid] = {};
+ graph[aid][id] = 1;
+ });
+}
+
+//choose start node
+var start = '10';
+//get all solutions
+var solutions = solve(graph, start);
+
+console.log("From '"+start+"' to");
+//display solutions
+for(var s in solutions) {
+ if(!solutions[s]) continue;
+ console.log(" -> " + s + ": [" + solutions[s].join(", ") + "] (dist:" + solutions[s].dist + ")");
+}
+
+// From '10' to
+// -> 2: [7, 5, 4, 2] (dist:4)
+// -> 3: [7, 5, 4, 3] (dist:4)
+// -> 4: [7, 5, 4] (dist:3)
+// -> 5: [7, 5] (dist:2)
+// -> 6: [7, 5, 4, 3, 6] (dist:5)
+// -> 7: [7] (dist:1)
+// -> 8: [7, 5, 4, 8] (dist:4)
+// -> 9: [7, 5, 4, 3, 13, 14, 9] (dist:7)
+// -> 10: [] (dist:0)
+// -> 11: [7, 5, 11] (dist:3)
+// -> 12: [7, 5, 11, 12] (dist:4)
+// -> 13: [7, 5, 4, 3, 13] (dist:5)
+// -> 14: [7, 5, 4, 3, 13, 14] (dist:6)
+// -> 15: [7, 5, 4, 3, 6, 15] (dist:6)
+// -> R: [7, 5, 4, 2, R] (dist:5)

maths/graph.js

@@ -0,0 +1,94 @@
+// create a graph class 
+class Graph { 
+ // defining vertex array and 
+ // adjacent list 
+ constructor(noOfVertices) 
+ { 
+ this.noOfVertices = noOfVertices; 
+ this.AdjList = new Map(); 
+ } 
+
+ // functions to be implemented 
+
+ // addVertex(v) 
+ // addEdge(v, w) 
+ // printGraph() 
+
+ // bfs(v) 
+ // dfs(v) 
+}
+
+// add vertex to the graph 
+addVertex(v) 
+{ 
+ // initialize the adjacent list with a 
+ // null array 
+ this.AdjList.set(v, []); 
+}
+
+// add edge to the graph 
+addEdge(v, w) 
+{ 
+ // get the list for vertex v and put the 
+ // vertex w denoting edge between v and w 
+ this.AdjList.get(v).push(w); 
+
+ // Since graph is undirected, 
+ // add an edge from w to v also 
+ this.AdjList.get(w).push(v); 
+} 
+
+
+// Prints the vertex and adjacency list 
+printGraph() 
+{ 
+ // get all the vertices 
+ var get_keys = this.AdjList.keys(); 
+
+ // iterate over the vertices 
+ for (var i of get_keys) 
+{ 
+ // great the corresponding adjacency list 
+ // for the vertex 
+ var get_values = this.AdjList.get(i); 
+ var conc = ""; 
+
+ // iterate over the adjacency list 
+ // concatenate the values into a string 
+ for (var j of get_values) 
+ conc += j + " "; 
+
+ // print the vertex and its adjacency list 
+ console.log(i + " -> " + conc); 
+ } 
+}
+
+
+// Example
+var graph = new Graph(6); 
+var vertices = [ 'A', 'B', 'C', 'D', 'E', 'F' ]; 
+
+// adding vertices 
+for (var i = 0; i < vertices.length; i++) { 
+ g.addVertex(vertices[i]); 
+} 
+
+// adding edges 
+g.addEdge('A', 'B'); 
+g.addEdge('A', 'D'); 
+g.addEdge('A', 'E'); 
+g.addEdge('B', 'C'); 
+g.addEdge('D', 'E'); 
+g.addEdge('E', 'F'); 
+g.addEdge('E', 'C'); 
+g.addEdge('C', 'F'); 
+
+// prints all vertex and 
+// its adjacency list 
+// A -> B D E 
+// B -> A C 
+// C -> B E F 
+// D -> A E 
+// E -> A D F C 
+// F -> E C 
+g.printGraph();