4.7 new solution working and test cases updated

Author: amejiarosario

src/trees-and-graphs/build-order.js

@@ -1,18 +1,68 @@
 const Graph = require('./graph').Graph;
 
 /**
+ *
  * 4.7 Build Order: You are given a list of projects and a list of dependencies (which is a list of pairs of projects, where the second project is dependent on the first project). All of a project's dependencies must be built before the project is. Find a build order that will allow the projects to be built. If there is no valid build order, return an error.
 
  EXAMPLE
 
  Input:
-    projects: a, b, c, d, e, f
-    dependencies: (a, d), (f, b), (b, d), (f, a), (d, c)
+ projects: a, b, c, d, e, f
+ dependencies: (a, d), (f, b), (b, d), (f, a), (d, c)
 
  Output: f, e, a, b, d, c
-
+ *
+ * @param projects
+ * @param dependencies
+ * @returns {Array}
  */
 function getBuildOrder(projects, dependencies) {
+  const list = [];
+
+  // build graph
+  const graph = new Graph();
+
+  projects.forEach(function (project) {
+    graph.add(project);
+  });
+
+  dependencies.forEach(function ([source, target]) {
+    graph.add(source, target);
+  });
+
+  // do DFS and unshift elements
+  const nodes = graph.getNodes();
+
+  try {
+    nodes.forEach(function (node) {
+      doDFS(node, list);
+    });
+  } catch (e) {
+    console.log(e.name + ': ' + e.message);
+  }
+
+  return list;
+}
+
+function doDFS(node, list) {
+  if(node.metadata.status === 'VISITED') {
+    return;
+  } else if(node.metadata.status === 'VISITING') {
+    throw new Error('Infinite loop detected');
+  }
+
+  node.metadata.status = 'VISITING';
+  node.adjacents.forEach(function (adj) {
+    doDFS(adj, list);
+  });
+
+  node.metadata.status = 'VISITED';
+  list.unshift(node.data);
+}
+
+//-------- OLD ----------
+
+function getBuildOrder2(projects, dependencies) {
   const graph = new Graph();
   const invGraph = new Graph();
   const result = new Set();

src/trees-and-graphs/build-order.spec.js

@@ -15,18 +15,32 @@ describe('Graph: build order', function () {
   it('should find the right order', function () {
     const projects = ['a', 'b', 'c', 'd', 'e', 'f'];
     const dependencies = [['a', 'd'], ['f', 'b'], ['b', 'd'], ['f', 'a'], ['d', 'c']];
-    expect(getBuildOrder(projects, dependencies).join()).to.equal('e,f,b,a,d,c');
-  });
-
-  it('should find the right order 2', function () {
-    const projects = ['a', 'b', 'c', 'd'];
-    const dependencies = [['a', 'b'], ['c', 'd']];
-    expect(getBuildOrder(projects, dependencies).join()).to.equal('a,b,c,d');
+    expect(getBuildOrder(projects, dependencies).join('')).to.be.oneOf([
+      'fabdce',
+      'fbadce',
+      'efabdc',
+      'efbadc',
+      'feabdc',
+      'febadc'
+    ]);
   });
 
   it('should work with complex graph', function () {
     const projects = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
     const dependencies = [['f', 'c'], ['f', 'b'], ['f', 'a'], ['c', 'a'], ['b', 'a'], ['a', 'e'], ['b', 'e'], ['d', 'g']];
-    expect(getBuildOrder(projects, dependencies).join()).to.equal('f,c,b,a');
+    expect(getBuildOrder(projects, dependencies).join('')).to.be.oneOf([
+      'fcbaedg',
+      'fbcaedg',
+      'fdgcbae',
+      'fdgbcae',
+      'dgfcbae',
+      'dgfbcae'
+    ]);
+  });
+
+  it('should return empty array if there is no solution', function () {
+    const projects = ['a', 'b'];
+    const dependencies = [['a', 'b'], ['b', 'a']];
+    expect(getBuildOrder(projects, dependencies)).to.eql([]);
   });
 });

src/trees-and-graphs/graph.js

@@ -73,12 +73,12 @@ class Graph {
     let sourceNode, targetNode;
 
     sourceNode = this.getNode(source);
-    targetNode = this.getNode(target);
+    if(target) targetNode = this.getNode(target);
 
-    sourceNode.adjacents.push(targetNode);
+    if(target) sourceNode.adjacents.push(targetNode);
 
     this.nodes.set(sourceNode.data, sourceNode);
-    this.nodes.set(targetNode.data, targetNode);
+    if(target) this.nodes.set(targetNode.data, targetNode);
 
     return sourceNode;
   }
@@ -101,6 +101,14 @@ class Graph {
     return node;
   }
 
+  /**
+   * Return an array with all the nodes
+   * @returns {Array}
+   */
+  getNodes() {
+    return Array.from(this.nodes.values());
+  }
+
   /**
    * Return adjacency matrix of the data
    * @returns {string}