Merge pull request #11 from trekhleb/master

 fix longestCommonSubstring() to handle unicode characters

Author: aalhour

.travis.yml

@@ -3,8 +3,11 @@ dist: trusty
 language: node_js
 node_js:
   - node
+install:
+  - npm install -g codecov
+  - npm install
 script:
   - npm run ci
-  - npm run codecov
+  - codecov
 notifications:
   email: false

README.md

@@ -19,6 +19,9 @@ _Read this in other languages:_
 [_Español_](README.es-ES.md),
 [_Português_](README.pt-BR.md)
 
+*☝ Note that this project is meant to be used for learning and researching purposes 
+only and it is **not** meant to be used for production.*
+
 ## Data Structures
 
 A data structure is a particular way of organizing and storing data in a computer so that it can
@@ -58,7 +61,7 @@ a set of rules that precisely define a sequence of operations.
 * **Math**
   * `B` [Bit Manipulation](src/algorithms/math/bits) - set/get/update/clear bits, multiplication/division by two, make negative etc.
   * `B` [Factorial](src/algorithms/math/factorial) 
-  * `B` [Fibonacci Number](src/algorithms/math/fibonacci)
+  * `B` [Fibonacci Number](src/algorithms/math/fibonacci) - classic and closed-form versions
   * `B` [Primality Test](src/algorithms/math/primality-test) (trial division method)
   * `B` [Euclidean Algorithm](src/algorithms/math/euclidean-algorithm) - calculate the Greatest Common Divisor (GCD)
   * `B` [Least Common Multiple](src/algorithms/math/least-common-multiple) (LCM)
@@ -67,6 +70,7 @@ a set of rules that precisely define a sequence of operations.
   * `B` [Pascal's Triangle](src/algorithms/math/pascal-triangle)
   * `B` [Complex Number](src/algorithms/math/complex-number) - complex numbers and basic operations with them
   * `B` [Radian & Degree](src/algorithms/math/radian) - radians to degree and backwards conversion
+  * `B` [Fast Powering](src/algorithms/math/fast-powering)
   * `A` [Integer Partition](src/algorithms/math/integer-partition)
   * `A` [Liu Hui π Algorithm](src/algorithms/math/liu-hui) - approximate π calculations based on N-gons
   * `A` [Discrete Fourier Transform](src/algorithms/math/fourier-transform) - decompose a function of time (a signal) into the frequencies that make it up 
@@ -105,6 +109,9 @@ a set of rules that precisely define a sequence of operations.
   * `B` [Shellsort](src/algorithms/sorting/shell-sort)
   * `B` [Counting Sort](src/algorithms/sorting/counting-sort)
   * `B` [Radix Sort](src/algorithms/sorting/radix-sort)
+* **Linked Lists**
+  * `B` [Straight Traversal](src/algorithms/linked-list/traversal)
+  * `B` [Reverse Traversal](src/algorithms/linked-list/reverse-traversal)
 * **Trees**
   * `B` [Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Breadth-First Search](src/algorithms/tree/breadth-first-search) (BFS)
@@ -163,6 +170,7 @@ algorithm is an abstraction higher than a computer program.
   * `B` [Tree Depth-First Search](src/algorithms/tree/depth-first-search) (DFS)
   * `B` [Graph Depth-First Search](src/algorithms/graph/depth-first-search) (DFS)
   * `B` [Jump Game](src/algorithms/uncategorized/jump-game)
+  * `B` [Fast Powering](src/algorithms/math/fast-powering)
   * `A` [Permutations](src/algorithms/sets/permutations) (with and without repetitions)
   * `A` [Combinations](src/algorithms/sets/combinations) (with and without repetitions)
 * **Dynamic Programming** - build up a solution using previously found sub-solutions
@@ -288,9 +296,3 @@ Below is the list of some of the most used Big O notations and their performance
 | **Shell sort**        | n&nbsp;log(n)   | depends on gap sequence   | n&nbsp;(log(n))<sup>2</sup>  | 1         | No         |           |
 | **Counting sort**     | n + r           | n + r               | n + r               | n + r     | Yes       | r - biggest number in array |
 | **Radix sort**        | n * k           | n * k               | n * k               | n + k     | Yes       | k - length of longest key |
-
-## The Book
-
-We’re writing a book that will clearly explain, in detail, the main algorithms. 
-If you’d like to be notified when the “JavaScript Algorithms” book 
-launches, [click here](https://upscri.be/402324/).

README.zh-CN.md

@@ -22,21 +22,21 @@ _Read this in other languages:_
 
 `B` - 初学者, `A` - 进阶
 
-* `B` [链表](src/data-structures/linked-list)
-* `B` [双向链表](src/data-structures/doubly-linked-list)
-* `B` [队列](src/data-structures/queue)
-* `B` [栈](src/data-structures/stack)
-* `B` [哈希表](src/data-structures/hash-table)
-* `B` [堆](src/data-structures/heap)
-* `B` [优先队列](src/data-structures/priority-queue)
+* `B` [链表](src/data-structures/linked-list/README.zh-CN.md)
+* `B` [双向链表](src/data-structures/doubly-linked-list/README.zh-CN.md)
+* `B` [队列](src/data-structures/queue/README.zh-CN.md)
+* `B` [栈](src/data-structures/stack/README.zh-CN.md)
+* `B` [哈希表](src/data-structures/hash-table/README.zh-CN.md)
+* `B` [堆](src/data-structures/heap/README.zh-CN.md)
+* `B` [优先队列](src/data-structures/priority-queue/README.zh-CN.md)
 * `A` [字典树](src/data-structures/trie)
-* `A` [树](src/data-structures/tree)
+* `A` [树](src/data-structures/tree/README.zh-CN.md)
   * `A` [二叉查找树](src/data-structures/tree/binary-search-tree)
   * `A` [AVL 树](src/data-structures/tree/avl-tree)
   * `A` [红黑树](src/data-structures/tree/red-black-tree)
   * `A` [线段树](src/data-structures/tree/segment-tree) - 使用 最小/最大/总和 范围查询示例
   * `A` [树状数组](src/data-structures/tree/fenwick-tree) (二叉索引树)
-* `A` [图](src/data-structures/graph) (有向图与无向图)
+* `A` [图](src/data-structures/graph/README.zh-CN.md) (有向图与无向图)
 * `A` [并查集](src/data-structures/disjoint-set)
 * `A` [布隆过滤器](src/data-structures/bloom-filter)
 

package-lock.json

@@ -6,8 +6,7 @@
   "scripts": {
     "lint": "eslint ./src/*",
     "test": "jest",
-    "ci": "npm run lint && npm run test -- --coverage",
-    "codecov": "codecov"
+    "ci": "npm run lint && npm run test -- --coverage"
   },
   "pre-commit": [
     "lint",
@@ -27,7 +26,9 @@
     "javascript-algorithms",
     "sorting-algorithms",
     "graph",
-    "tree"
+    "tree",
+    "interview",
+    "interview-preparation"
   ],
   "author": "Oleksii Trekhleb (https://www.linkedin.com/in/trekhleb/)",
   "license": "MIT",
@@ -39,7 +40,6 @@
     "@types/jest": "^23.1.4",
     "babel-cli": "^6.26.0",
     "babel-preset-env": "^1.7.0",
-    "codecov": "^3.0.2",
     "eslint": "^4.19.1",
     "eslint-config-airbnb": "^17.0.0",
     "eslint-plugin-import": "^2.13.0",

package.json

@@ -0,0 +1,19 @@
+# Reversed Linked List Traversal
+
+The task is to traverse the given linked list in reversed order.
+
+For example for the following linked list: 
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+The order of traversal should be:
+
+```text
+37 → 99 → 12
+```
+
+The time complexity is `O(n)` because we visit every node only once.
+
+## Reference
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/linked-list/reverse-traversal/README.md

@@ -0,0 +1,36 @@
+import LinkedList from '../../../../data-structures/linked-list/LinkedList';
+import reverseTraversal from '../reverseTraversal';
+
+describe('reverseTraversal', () => {
+  it('should traverse linked list in reverse order', () => {
+    const linkedList = new LinkedList();
+
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    const traversedNodeValues = [];
+    const traversalCallback = (nodeValue) => {
+      traversedNodeValues.push(nodeValue);
+    };
+
+    reverseTraversal(linkedList, traversalCallback);
+
+    expect(traversedNodeValues).toEqual([3, 2, 1]);
+  });
+});
+
+
+// it('should reverse traversal the linked list with callback', () => {
+//   const linkedList = new LinkedList();
+//
+//   linkedList
+//     .append(1)
+//     .append(2)
+//     .append(3);
+//
+//   expect(linkedList.toString()).toBe('1,2,3');
+//   expect(linkedList.reverseTraversal(linkedList.head, value => value * 2)).toEqual([6, 4, 2]);
+//   expect(() => linkedList.reverseTraversal(linkedList.head)).toThrow();
+// });

src/algorithms/linked-list/reverse-traversal/__test__/reverseTraversal.test.js

@@ -0,0 +1,24 @@
+/**
+ * Traversal callback function.
+ * @callback traversalCallback
+ * @param {*} nodeValue
+ */
+
+/**
+ * @param {LinkedListNode} node
+ * @param {traversalCallback} callback
+ */
+function reverseTraversalRecursive(node, callback) {
+  if (node) {
+    reverseTraversalRecursive(node.next, callback);
+    callback(node.value);
+  }
+}
+
+/**
+ * @param {LinkedList} linkedList
+ * @param {traversalCallback} callback
+ */
+export default function reverseTraversal(linkedList, callback) {
+  reverseTraversalRecursive(linkedList.head, callback);
+}

src/algorithms/linked-list/reverse-traversal/reverseTraversal.js

@@ -0,0 +1,19 @@
+# Linked List Traversal
+
+The task is to traverse the given linked list in straight order.
+
+For example for the following linked list: 
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+The order of traversal should be:
+
+```text
+12 → 99 → 37
+```
+
+The time complexity is `O(n)` because we visit every node only once.
+
+## Reference
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/linked-list/traversal/README.md

@@ -0,0 +1,22 @@
+import LinkedList from '../../../../data-structures/linked-list/LinkedList';
+import traversal from '../traversal';
+
+describe('traversal', () => {
+  it('should traverse linked list', () => {
+    const linkedList = new LinkedList();
+
+    linkedList
+      .append(1)
+      .append(2)
+      .append(3);
+
+    const traversedNodeValues = [];
+    const traversalCallback = (nodeValue) => {
+      traversedNodeValues.push(nodeValue);
+    };
+
+    traversal(linkedList, traversalCallback);
+
+    expect(traversedNodeValues).toEqual([1, 2, 3]);
+  });
+});