Merge pull request #125 from Nur69/master

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();