From 95bba0b0ea2325055133829f28f8d01981e8ac90 Mon Sep 17 00:00:00 2001 From: vinayak Date: Sun, 3 May 2020 01:03:10 +0530 Subject: [PATCH] update (#1) * Graph Theory * Delete Graphs * Graph * Dijkstra Smallest Path * DijkstraSmallestPath after fixing some errors. * Topological Sort directed graphs * correcting name of file * updating DIRECTORY.md * doublylinkedlist * add-doublylinkedlist * add-doublylinkedlist * change in Directory.md * updating DIRECTORY.md Co-authored-by: Nur69 <60115902+Nur69@users.noreply.github.com> Co-authored-by: Stepfen Shawn Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: hmizz --- DIRECTORY.md | 4 + .../Linked List/DoublyLinkedList.js | 197 ++++++++++++++++++ Sorts/TopologicalSort.js | 59 ++++++ maths/DijkstraSmallestPath.js | 118 +++++++++++ maths/graph.js | 94 +++++++++ 5 files changed, 472 insertions(+) create mode 100644 Data Structures/Linked List/DoublyLinkedList.js create mode 100644 Sorts/TopologicalSort.js create mode 100644 maths/DijkstraSmallestPath.js create mode 100644 maths/graph.js diff --git a/DIRECTORY.md b/DIRECTORY.md index b986905b2..c433585b7 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -22,6 +22,7 @@ * Heap * [MinPriorityQueue](https://github.com/TheAlgorithms/Javascript/blob/master/Data%20Structures/Heap/MinPriorityQueue.js) * Linked List + * [DoublyLinkedList](https://github.com/TheAlgorithms/Javascript/blob/master/Data%20Structures/Linked%20List/DoublyLinkedList.js) * [singlylinklist](https://github.com/TheAlgorithms/Javascript/blob/master/Data%20Structures/Linked%20List/singlylinklist.js) * Queue * [Queue](https://github.com/TheAlgorithms/Javascript/blob/master/Data%20Structures/Queue/Queue.js) @@ -43,8 +44,10 @@ ## maths * [abs](https://github.com/TheAlgorithms/Javascript/blob/master/maths/abs.js) * [average mean](https://github.com/TheAlgorithms/Javascript/blob/master/maths/average_mean.js) + * [DijkstraSmallestPath](https://github.com/TheAlgorithms/Javascript/blob/master/maths/DijkstraSmallestPath.js) * [factorial](https://github.com/TheAlgorithms/Javascript/blob/master/maths/factorial.js) * [find lcm](https://github.com/TheAlgorithms/Javascript/blob/master/maths/find_lcm.js) + * [graph](https://github.com/TheAlgorithms/Javascript/blob/master/maths/graph.js) ## Search * [binarySearch](https://github.com/TheAlgorithms/Javascript/blob/master/Search/binarySearch.js) @@ -68,4 +71,5 @@ * [radixSort](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/radixSort.js) * [selectionSort](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/selectionSort.js) * [shellSort](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/shellSort.js) + * [TopologicalSort](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/TopologicalSort.js) * [wiggleSort](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/wiggleSort.js) diff --git a/Data Structures/Linked List/DoublyLinkedList.js b/Data Structures/Linked List/DoublyLinkedList.js new file mode 100644 index 000000000..aca5b7eb7 --- /dev/null +++ b/Data Structures/Linked List/DoublyLinkedList.js @@ -0,0 +1,197 @@ +//Hamza chabchoub contribution for a university project +function doubleLinkedList() { + let Node = function(element) { + this.element = element; + this.next = null; + this.prev = null; + } + + let length = 0; + let head = null; + let tail = null; + + //Add new element + this.append = function(element) { + let node = new Node(element); + + if(!head){ + head = node; + tail = node; + }else{ + node.prev = tail; + tail.next = node; + tail = node; + } + + length++; + } + + + //Add element + this.insert = function(position, element) { + + //Check of out-of-bound values + if(position >= 0 && position <= length){ + let node = new Node(element), + current = head, + previous, + index = 0; + + if(position === 0){ + if(!head){ + head = node; + tail = node; + }else{ + node.next = current; + current.prev = node; + head = node; + } + }else if(position === length){ + current = tail; + current.next = node; + node.prev = current; + tail = node; + }else{ + while(index++ < position){ + previous = current; + current = current.next; + } + + node.next = current; + previous.next = node; + + //New + current.prev = node; + node.prev = previous; + } + + length++; + return true; + }else{ + return false; + } + } + + //Remove element at any position + this.removeAt = function(position){ + //look for out-of-bounds value + if(position > -1 && position < length){ + let current = head, previous, index = 0; + + //Removing first item + if(position === 0){ + head = current.next; + + //if there is only one item, update tail //NEW + if(length === 1){ + tail = null; + }else{ + head.prev = null; + } + }else if(position === length - 1){ + current = tail; + tail = current.prev; + tail.next = null; + }else{ + while(index++ < position){ + previous = current; + current = current.next; + } + + //link previous with current's next - skip it + previous.next = current.next; + current.next.prev = previous; + } + + length--; + return current.element; + }else{ + return null; + } + } + + //Get the indexOf item + this.indexOf = function(elm){ + let current = head, + index = -1; + + //If element found then return its position + while(current){ + if(elm === current.element){ + return ++index; + } + + index++; + current = current.next; + } + + //Else return -1 + return -1; + }; + + //Find the item in the list + this.isPresent = (elm) => { + return this.indexOf(elm) !== -1; + }; + + //Delete an item from the list + this.delete = (elm) => { + return this.removeAt(this.indexOf(elm)); + }; + + //Delete first item from the list + this.deleteHead = function(){ + this.removeAt(0); + } + + //Delete last item from the list + this.deleteTail = function(){ + this.removeAt(length-1); + } + + //Print item of the string + this.toString = function(){ + let current = head, + string = ''; + + while(current){ + string += current.element + (current.next ? '\n' : ''); + current = current.next; + } + + return string; + }; + + //Convert list to array + this.toArray = function(){ + let arr = [], + current = head; + + while(current){ + arr.push(current.element); + current = current.next; + } + + return arr; + }; + + //Check if list is empty + this.isEmpty = function(){ + return length === 0; + }; + + //Get the size of the list + this.size = function(){ + return length; + } + + //Get the head + this.getHead = function() { + return head; + } + + //Get the tail + this.getTail = function() { + return tail; + } + } \ No newline at end of file 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();