add bfs and dfs, change directory structure

Author: dingjy94

.eslintrc.json

@@ -19,6 +19,7 @@
         "jest/no-focused-tests": "error",
         "jest/no-identical-title": "error",
         "jest/prefer-to-have-length": "warn",
-        "jest/valid-expect": "error"
+        "jest/valid-expect": "error",
+        "no-plusplus": [2, { "allowForLoopAfterthoughts": true }]
     }
 }

README.md

@@ -4,9 +4,9 @@ My personal note learn JavaScript
 ## Curriculum
 This curriculum based on the one of (ACM-ICPC-Preparation)[https://github.com/NAU-ACM/ACM-ICPC-Preparation], but didn't follow the order.
 
-|     | Data Structure | Algorithm | Tutorial | Questions |
-| --- | -------------- | --------- | -------- | --------- |
-| 1   | <ul><li>[Queue](/dataStructure/queue/queue.js)</li><li>[Stack](/dataStructure/stack/stack.js)</li></ul> | <ul><li>DFS</li><li>BFS</li></ul> | [Data Structures: Stacks and Queues (Youtube)](https://www.youtube.com/watch?v=wjI1WNcIntg) | <ul><li>[ Valid Parentheses](https://leetcode.com/problems/valid-parentheses/)</li><li>[Largest Rectangle in Histogram](https://leetcode.com/problems/largest-rectangle-in-histogram/)[\(my solution\)](/questions/largestRectangleArea.js)</li></ul>|
+|     | Data Structure | Algorithm |
+| --- | -------------- | --------- |
+| 1   | <ul><li>[Queue](/dataStructure/queue/README.md)</li><li>[Stack](/dataStructure/stack/README.md)</li></ul> | <ul><li>DFS</li><li>[BFS](/algorithm/Graph/bfs/README.md)</li></ul> |
 
 ## algorithm
 1. [useful tricky (tricky methods depends on JavaScript features)](/algorithm/useful_trick.md)

algorithm/Graph/bfs/README.md

@@ -0,0 +1,15 @@
+# Breadth-First-Search (BFS)
+Search algorithm used to traverse or serach through a graph. Start from a grpah vertex, and **traverse** all this vertext's neighboor nodes first, then move to next level.
+
+## Implement Keys
+- For graph, we need to maintain a `visited array` to record which node is visited.
+- For BFS, we use queue. The FIFO data structure promise to traverse all nodes in the higher level before go to next level.
+- [source code](bfs.js) (I used my own queue, but in face we can just use JavaScript's array to simulate a queue, use `shift` to dequeue, `push` to enqueue).
+
+## Questions
+- [clone graph](https://leetcode.com/problems/clone-graph/)
+
+## Resource
+- [Graph Traversals - Breadth First and Depth First (Youtube)](https://www.youtube.com/watch?v=bIA8HEEUxZI)
+- [The Breadth First search algorithm (Khanacademy)](https://www.khanacademy.org/computing/computer-science/algorithms/breadth-first-search/a/the-breadth-first-search-algorithm)
+- [GeeksforGeeks](https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/)

algorithm/Graph/bfs/bfs.js

@@ -0,0 +1,34 @@
+// return a BFS traversal of a graph
+import Queue from '../../../dataStructure/queue/queue';
+
+const bfs = (graph, start) => {
+  const visited = [];
+  const result = [];
+  const queue = new Queue(); // can also use JavaScript array
+
+  queue.add(start);
+  const startIndex = graph.vertices.indexOf(start);
+  visited[startIndex] = 1;
+
+  while (!queue.isEmpty()) {
+    const cur = queue.remove();
+    result.push(cur);
+    const index = graph.vertices.indexOf(cur);
+    visited[index] = 1;
+
+    const neighbors = graph.adjList.get(cur);
+    neighbors.forEach((n) => {
+      const nIndex = graph.vertices.indexOf(n);
+      if (visited[nIndex]) {
+        return;
+      }
+
+      visited[nIndex] = 1;
+      queue.add(n);
+    });
+  }
+
+  return result;
+};
+
+export default bfs;

algorithm/Graph/bfs/bfs.test.js

@@ -0,0 +1,27 @@
+import bfs from './bfs';
+import Graph from '../../../dataStructure/graph/graph';
+
+describe('Graph BFS', () => {
+  const g = new Graph();
+  const vertices = ['A', 'B', 'C', 'D', 'E', 'F'];
+
+  // adding vertices
+  for (let 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');
+
+
+  it('return correct BFS traversal', () => {
+    expect(bfs(g, 'A')).toEqual(['A', 'B', 'D', 'E', 'C', 'F']);
+  });
+});

algorithm/Graph/dfs/dfs.js

@@ -0,0 +1,58 @@
+// return a DFS traversal of given graph
+import Stack from '../../../dataStructure/stack/stack';
+
+const stackDfs = (graph, start) => {
+  const stack = new Stack();
+  const visited = [];
+  const result = [];
+
+  const startIndex = graph.vertices.indexOf(start);
+  visited[startIndex] = 1;
+  stack.push(start);
+  result.push(start);
+
+  while (!stack.isEmpty()) {
+    const cur = stack.peek();
+    const index = graph.vertices.indexOf(cur);
+    if (!visited[index]) {
+      result.push(cur);
+      visited[index] = 1;
+    }
+
+    const neighbors = graph.adjList.get(cur);
+    const firstUnvisitedN = neighbors.find((n) => {
+      const nIndex = graph.vertices.indexOf(n);
+      return !visited[nIndex];
+    });
+    if (firstUnvisitedN) {
+      stack.push(firstUnvisitedN);
+    } else {
+      stack.pop();
+    }
+  }
+
+  return result;
+};
+
+// recursive version
+const recursiveDfsHelper = (graph, cur, visited, result) => {
+  visited[graph.vertices.indexOf(cur)] = 1; // eslint-disable-line no-param-reassign
+  result.push(cur);
+  const neighbors = graph.adjList.get(cur);
+  neighbors.forEach((n) => {
+    if (!visited[graph.vertices.indexOf(n)]) {
+      recursiveDfsHelper(graph, n, visited, result);
+    }
+  });
+};
+
+const recursiveDfs = (graph, start) => {
+  const visited = [];
+  const result = [];
+
+  recursiveDfsHelper(graph, start, visited, result);
+
+  return result;
+};
+
+export { stackDfs, recursiveDfs };

algorithm/Graph/dfs/dfs.test.js

@@ -0,0 +1,32 @@
+import { stackDfs, recursiveDfs } from './dfs';
+import Graph from '../../../dataStructure/graph/graph';
+
+const g = new Graph();
+const vertices = ['A', 'B', 'C', 'D', 'E', 'F'];
+
+// adding vertices
+for (let 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');
+
+describe('Graph DFS stack version', () => {
+  it('return correct DFS traversal', () => {
+    expect(stackDfs(g, 'A')).toEqual(['A', 'B', 'C', 'E', 'D', 'F']);
+  });
+});
+
+describe('Graph DFS recursive version', () => {
+  it('return correct DFS traversal', () => {
+    expect(recursiveDfs(g, 'A')).toEqual(['A', 'B', 'C', 'E', 'D', 'F']);
+  });
+});

algorithm/String/README.md

@@ -0,0 +1,15 @@
+## Array
+### Get max, second max value of array of numbers
+```JavaScript
+  const max = Math.max(...nums); // for es5, use Math.max.apply(null, nums);
+
+  nums[nums.indexOf(max);] = -Infinity;
+  const secondMax = Math.max(...nums);
+```
+
+## String
+### reverse string
+```JavaScript
+  return s.split('').reverse().join('')
+```
+

algorithm/index.md renamed to algorithm/String/kmp/README.md

@@ -1,19 +1,4 @@
-## Array
-### Get max, second max value of array of numbers
-```JavaScript
-  const max = Math.max(...nums); // for es5, use Math.max.apply(null, nums);
-
-  nums[nums.indexOf(max);] = -Infinity;
-  const secondMax = Math.max(...nums);
-```
-
-## String
-### reverse string
-```JavaScript
-  return s.split('').reverse().join('')
-```
-
-### KMP
+# KMP
 KMP is an algorithm which can be used to do pattern searching (check substring, palindrome).
 
 The KMP matching algorithm uses degenerating property (pattern having same sub-patterns appearing more than once in the pattern) of the pattern and improves the worst case complexity to O(n). The basic idea behind KMP’s algorithm is: whenever we detect a mismatch (after some matches), we already know some of the characters in the text of the next window.
@@ -22,5 +7,3 @@ Two steps:
 1. preprocess: get the get lps (longest proper prefix which is also suffix) array of pattern string. `lps[i]` means the lps for substring(0, i + 1).
 
 2. search: when **mismatch**, let's say the index of pattern is j, text string index is i, which means `pattern[0, j - 1] == text[i - j, i - 1]`, and from `lps[j - 1]`, we can get the lps length. So in text[i - j, i - 1], there is a `prefix == suffix` whose length is lps[i - 1]. So, we know that the suffix of `text[0, i - 1]` will match prefix of `pattern[0, lps[j - 1]]`, so the next comparision is between `text[i]` and `pattern[lps[j - 1]]`.
-
-Example: [Pattern Searching](/String/kmp.js)

algorithm/String/kmp.js renamed to algorithm/String/kmp/kmp.js

@@ -2,7 +2,8 @@
  * Pattern Searching
  *
  * Given a text txt[0..n-1] and a pattern pat[0..m-1],
- * write a function search(char pat[], char txt[]) that prints all occurrences index of pat[] in txt[].
+ * write a function search(char pat[],
+ * char txt[]) that prints all occurrences index of pat[] in txt[].
  * You may assume that n > m.
  *
  * KMP (Knuth Morris Pratt) Pattern Searching
@@ -13,58 +14,54 @@
  * O(n)
  */
 
+// compute longest proper prefix (longest proper prefix which is also suffix)
+const computeLPS = function computeLPS(pat) {
+  let prevLen = 0;
+  let curIndex = 1;
+  const lps = [0];
+
+  while (curIndex < pat.length) {
+    if (pat.charAt(curIndex) === pat.charAt(prevLen)) {
+      prevLen += 1;
+      lps.push(prevLen);
+      curIndex += 1;
+    } else if (prevLen !== 0) {
+      prevLen = lps[prevLen - 1];
+    } else {
+      lps.push(0);
+      curIndex += 1;
+    }
+  }
+
+  return lps;
+};
 
-function KMPStringMatching(pat, txt) {
+const KMPStringMatching = function KMPStringMatching(pat, txt) {
   const result = [];
   const lps = computeLPS(pat);
 
-  let patIndex = 0, txtIndex = 0;
+  let patIndex = 0;
+  let txtIndex = 0;
 
   while (txtIndex < txt.length) {
     if (pat.charAt(patIndex) === txt.charAt(txtIndex)) {
-      patIndex++;
-      txtIndex++;
+      patIndex += 1;
+      txtIndex += 1;
     }
 
     if (patIndex === pat.length) {
       result.push(txtIndex - patIndex);
       patIndex = lps[patIndex - 1];
-    }
-
-    else if (txtIndex < txt.length && pat.charAt(patIndex) !== txt.charAt(txtIndex)) {
+    } else if (txtIndex < txt.length && pat.charAt(patIndex) !== txt.charAt(txtIndex)) {
       if (patIndex !== 0) {
         patIndex = lps[patIndex - 1];
       } else {
-        txtIndex++;
+        txtIndex += 1;
       }
     }
   }
 
   return result;
-}
-
-// compute longest proper prefix (longest proper prefix which is also suffix)
-function computeLPS(pat) {
-  let prevLen = 0;
-  let curIndex = 1;
-  const lps = [0];
-
-  while (curIndex < pat.length) {
-    if (pat.charAt(curIndex) === pat.charAt(prevLen)) {
-      prevLen++;
-      lps.push(prevLen);
-      curIndex++;
-    } else {
-      if (prevLen !== 0) {
-        prevLen = lps[prevLen - 1];
-      } else {
-        lps.push(0);
-        curIndex++;
-      }
-    }
-  }
-
-  return lps;
-}
+};
 
 export default KMPStringMatching;

algorithm/String/kmp.test.js renamed to algorithm/String/kmp/kmp.test.js

@@ -0,0 +1,38 @@
+// Undirected Graph class TODO: remove vertex
+export default class Graph {
+  /**
+   * initialize a graph
+   */
+  constructor() {
+    this.vertices = [];
+    this.adjList = new Map();
+  }
+
+  /**
+   * add vertice
+   * @param {} vertice - vertice name (index)
+   */
+  addVertex(vertice) {
+    this.vertices.push(vertice);
+    this.adjList.set(vertice, []);
+  }
+
+  /**
+   * connet two vertices
+   * @param {*} v1 - name of first vertice
+   * @param {*} v2 - name of second vertice
+   */
+  addEdge(v1, v2) {
+    this.adjList.get(v1).push(v2);
+    this.adjList.get(v2).push(v1);
+  }
+
+  toString() {
+    let str = '';
+    this.vertices.forEach((v) => {
+      str += `${v} -> ${this.adjList.get(v).toString()} \n`;
+    });
+
+    return str;
+  }
+}