diff --git a/Sorts/TopologicalSort.js b/Sorts/TopologicalSort.js new file mode 100644 index 000000000..e76bfd666 --- /dev/null +++ b/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()); diff --git a/maths/DijkstraSmallestPath.js b/maths/DijkstraSmallestPath.js new file mode 100644 index 000000000..059b59461 --- /dev/null +++ b/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) diff --git a/maths/graph.js b/maths/graph.js new file mode 100644 index 000000000..45f3908aa --- /dev/null +++ b/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();