Adding Graph chapter

Author: crizstian

11-chapter-1-adjencency-matrix-Graphs.js

@@ -0,0 +1,91 @@
+class Graph {
+  constructor(vertices = [], edges = 0) {
+    this.vertices   = vertices;
+    this.adjencency = this.fillAdjencencyArray();
+    this.edges      = edges;
+  }
+
+  fillAdjencencyArray() {
+    let arr = [];
+    for (let i = 0; i < this.vertices.length; i++) {
+      arr[i] = [];
+      for (let j = 0; j < this.vertices.length; j++) {
+        arr[i].push(0);
+      }
+    }
+    return arr;
+  }
+
+  addEdge(v,w) {
+    const a = this.vertices.indexOf(v);
+    const b = this.vertices.indexOf(w);
+
+    this.edges++;
+
+    if(this.adjencency[a][b] === 1 ) {
+      this.adjencency[a][b]++;
+      return;
+    }
+
+    this.adjencency[a][b] = 1;
+    this.adjencency[b][a] = 1;
+  }
+
+  showGraph() {
+    let val = '  -> ';
+    for (const v in this.vertices) {
+      val += `${this.vertices[v]} `
+    }
+    console.log(val);
+    for (const v in this.adjencency) {
+      let value = `${this.vertices[v]} -> `;
+      for (const w in this.adjencency[v]) {
+        if (this.adjencency[v][w] !== undefined) {
+          value += `${this.adjencency[v][w]} `
+        }
+      }
+      console.log(value);
+    }
+  }
+
+  getNumOfVertices() {
+    return this.vertices.length;
+  }
+
+  getNumOfEdges() {
+    return this.edges;
+  }
+
+  getValancy(vertex) {
+    const vIndex = this.vertices.indexOf(vertex);
+    let valency  = 0;
+    for (var i = 0; i < this.adjencency.length; i++) {
+      valency += (this.adjencency[i][vIndex] !== 0) ? this.adjencency[i][vIndex] : 0;
+    }
+    let valency2  = 0;
+    for (var i = 0; i < this.adjencency.length; i++) {
+      valency2 += (this.adjencency[vIndex][i] !== 0) ? this.adjencency[vIndex][i] : 0;
+    }
+    return (valency > valency2) ? valency : valency2;
+  }
+
+}
+
+// Implementation
+// #############################################
+const vertices = ['a','b','c','d'];
+const g = new Graph(vertices);
+g.addEdge('a','b');
+g.addEdge('a','d');
+g.addEdge('b','c');
+g.addEdge('b','d');
+g.addEdge('c','b');
+g.addEdge('d','d');
+g.showGraph();
+console.log();
+console.log(`Number of edges: ${g.getNumOfEdges()}`);
+console.log();
+for (let i = 0; i < vertices.length; i++) {
+  console.log(`Valency of ${vertices[i]}: ${g.getValancy(vertices[i])}`);
+}
+console.log();

11-chapter-2-adjecency-list-Graphs.js

@@ -0,0 +1,85 @@
+class Graph {
+  constructor(vertices = [], edges = 0) {
+    this.vertices   = vertices;
+    this.adjencency = this.fillAdjencencyList();
+    this.edges      = edges;
+    this.marked     = new Array(vertices).fill(false);
+  }
+
+  fillAdjencencyList() {
+    let arr = [];
+    for (let i = 0; i < this.vertices; i++) {
+      arr[i] = [];
+    }
+    return arr;
+  }
+
+  addEdge(v,w) {
+    if (this.adjencency[v].indexOf(w) === -1 && this.adjencency[w].indexOf(v) === -1) {
+      this.adjencency[v].push(w);
+      this.adjencency[w].push(v);
+      this.edges++;
+    }
+  }
+
+  showGraph() {
+    let val = '';
+    for (const v in this.adjencency) {
+      let value = `${v} -> `;
+      for (const w in this.adjencency[v]) {
+        if (this.adjencency[v][w] !== undefined) {
+          value += `${this.adjencency[v][w]} `
+        }
+      }
+      console.log(value);
+    }
+  }
+
+  dfs(node) {
+    if (this.marked[node]) {
+      return;
+    }
+    console.log(`visited node at: ${node}`);
+    this.marked[node] = true;
+    if (this.adjencency[node] !== undefined) {
+      for (const w in this.adjencency[node]) {
+         this.dfs(this.adjencency[node][w]);
+      }
+    }
+  }
+
+  bfs(node) {
+    let queue = [node];
+    while (queue.length > 0) {
+      let v = queue.shift();
+      this.marked[v] = true;
+      console.log(`visited node at: ${v}`);
+      for (const w in this.adjencency[v]) {
+        let n = this.adjencency[v][w];
+        if (!this.marked[n]) {
+          queue.push(this.adjencency[v][w]);
+        }
+      }
+    }
+  }
+}
+
+// Implementation
+// #############################################
+const g = new Graph(5);
+g.addEdge(0,1);
+g.addEdge(0,2);
+g.addEdge(1,3);
+g.addEdge(2,4);
+g.showGraph();
+let t0 = new Date().getTime();
+g.dfs(0);
+let t1 = new Date().getTime();
+console.log("Call to dfs took " + (t1 - t0) + " milliseconds.")
+
+g.marked = new Array(g.vertices).fill(false);
+console.log();
+let t2 = new Date().getTime();
+g.bfs(0);
+let t3 = new Date().getTime();
+console.log("Call to bfs took " + (t3 - t2) + " milliseconds.")

11-chapter-Graphs.js

@@ -22,7 +22,8 @@ The purpose of this repo is to update the exercises to ES6 standards and to corr
 | 9.- | [Hashing](./08-chapter-Hashing.js) | 2 | `Hashing` is a common technique for storing data in such a way that the data can be inserted and retrieved very quickly. Hashing uses a data structure called a hash table. Although hash tables provide fast insertion, deletion, and retrieval, they perform poorly for operations that involve searching.
 | 10.- | [Set](./09-chapter-Set.js) | 4 | A `Set` is a collection of unique elements. The elements of a set are called members. The two most important properties of sets are that the members of a set are unordered and that no member can occur in a set more than once.
 | 11.- | [Binary Trees and Binary Search Trees](./10-chapter-Binary-Trees.js) | 4 | `Binary trees` are chosen over other more primary data structures because you can search a binary tree very quickly (as opposed to a linked list, for example) and you can quickly insert and delete data from a binary tree (as opposed to an array).
-| 12.- | [Graphs and Graphs Algorithms](./11-chapter-Graphs.js) | | A graph consists of a set of vertices and a set of edges. Think of a map of a US state. Each town is connected with other towns via some type of road. A map is a type of graph where each town is a vertex, and a road that connects two towns is an edge. Edges are defined as a pair (v1, v2), where v1 and v2 are two vertices in a graph
+| 12.- | [Simple Graphs](./11-chapter-1-MatrixAdjencency-Graphs.js) | 2 | A graph consists of a set of vertices and a set of edges. A map is a type of graph where each town is a vertex, and a road that connects two towns is an edge. Edges are defined as a pair (v1, v2), where v1 and v2 are two vertices in a graph
+| 13.- | [Complete Graphs](./11-chapter-2-ArrayListAdjecency-Graphs.js) | 2 | A complete graph is where all vertices are conected with each other.
 
 
 ### To run the examples we need the following: