Add ES6 Examples to all chapters (#38)

* add ES6 example for binary search

* add ES6 example for selection sort

* add ES6 example for countdown

* add ES6 example for greet

* add ES6 example for factorial

* edit ES6 example for quicksort

* add ES6 example for loop sum

* add ES6 example for recursive sum

* add ES6 example for recursive count

* add ES6 example for recursive max

* add ES6 example for price of groceries

* add ES6 example for check voter

* add ES6 example for breadth-first search

* add ES6 example for dijkstras algorithm

* edit ES6 example for dijkstras algorithm

* edit ES6 example for set covering

* add ES6 example for longest common subsequence

07_dijkstras_algorithm/ES6/01_dijkstras_algorithm.js

@@ -0,0 +1,72 @@
+// the graph
+const graph = {};
+graph.start = {};
+graph.start.a = 6;
+graph.start.b = 2;
+
+graph.a = {};
+graph.a.fin = 1;
+
+graph.b = {};
+graph.b.a = 3;
+graph.b.fin = 5;
+
+graph.fin = {};
+
+// The costs table
+const costs = {};
+costs.a = 6;
+costs.b = 2;
+costs.fin = Infinity;
+
+// the parents table
+const parents = {};
+parents.a = 'start';
+parents.b = 'start';
+parents.fin = null;
+
+let processed = [];
+
+
+const findLowestCostNode = (itCosts) => {
+  let lowestCost = Infinity;
+  let lowestCostNode = null;
+
+  Object.keys(itCosts).forEach((node) => {
+    const cost = itCosts[node];
+    // If it's the lowest cost so far and hasn't been processed yet...
+    if (cost < lowestCost && (processed.indexOf(node) === -1)) {
+      // ... set it as the new lowest-cost node.
+      lowestCost = cost;
+      lowestCostNode = node;
+    }
+  });
+  return lowestCostNode;
+};
+
+let node = findLowestCostNode(costs);
+
+while (node !== null) {
+  const cost = costs[node];
+  // Go through all the neighbors of this node
+  const neighbors = graph[node];
+  Object.keys(neighbors).forEach((n) => {
+    const newCost = cost + neighbors[n];
+    // If it's cheaper to get to this neighbor by going through this node
+    if (costs[n] > newCost) {
+      // ... update the cost for this node
+      costs[n] = newCost;
+      // This node becomes the new parent for this neighbor.
+      parents[n] = node;
+    }
+  });
+
+  // Mark the node as processed
+  processed = processed.concat(node);
+
+  // Find the next node to process, and loop
+  node = findLowestCostNode(costs);
+}
+
+console.log('Cost from the start to each node:');
+console.log(costs); // { a: 5, b: 2, fin: 6 }