Merge pull request #12 from trekhleb/master

Add iterative version of Euclidean algorithm

Author: aalhour

CONTRIBUTING.md

@@ -9,7 +9,7 @@
 **Contributing New Translation**
 
 - Create new `README.xx-XX.md` file with translation alongside with 
-main `README.md` file where `xx-XX` is locale and country/region codes.
+main `README.md` file where `xx-XX` is [locale and country/region codes](http://www.lingoes.net/en/translator/langcode.htm).
 For example `en-US`, `zh-CN`, `zh-TW`, `ko-KR` etc.
 - You may also translate all other sub-folders by creating 
 related `README.xx-XX.md` files in each of them.

README.zh-CN.md

@@ -51,10 +51,10 @@ _Read this in other languages:_
   * `B` [阶乘](src/algorithms/math/factorial)
   * `B` [斐波那契数](src/algorithms/math/fibonacci)
   * `B` [素数检测](src/algorithms/math/primality-test) (排除法)
-  * `B` [欧几里得算法](src/algorithms/math/euclidean-algorithm) - 计算最大公约数 (GCD) 
+  * `B` [欧几里得算法](src/algorithms/math/euclidean-algorithm) - 计算最大公约数 (GCD)
   * `B` [最小公倍数](src/algorithms/math/least-common-multiple) (LCM)
   * `B` [素数筛](src/algorithms/math/sieve-of-eratosthenes) - 查找所有素数达到任何给定限制
-  * `B` [判断2次方数](src/algorithms/math/is-power-of-two) - 检查数字是否为2的幂 (原生和按位算法) 
+  * `B` [判断2次方数](src/algorithms/math/is-power-of-two) - 检查数字是否为2的幂 (原生和按位算法)
   * `B` [杨辉三角形](src/algorithms/math/pascal-triangle)
   * `A` [整数拆分](src/algorithms/math/integer-partition)
   * `A` [割圆术](src/algorithms/math/liu-hui) - 基于N-gons的近似π计算
@@ -73,7 +73,7 @@ _Read this in other languages:_
 * **字符串**
   * `A` [莱温斯坦距离](src/algorithms/string/levenshtein-distance) - 两个序列之间的最小编辑距离
   * `B` [汉明距离](src/algorithms/string/hamming-distance) - 符号不同的位置数
-  * `A` [克努斯-莫里斯-普拉特算法](src/algorithms/string/knuth-morris-pratt) - 子串搜索
+  * `A` [KMP算法](src/algorithms/string/knuth-morris-pratt) (克努斯-莫里斯-普拉特算法) - 子串搜索 (模式匹配)
   * `A` [字符串快速查找](src/algorithms/string/rabin-karp) - 子串搜索
   * `A` [最长公共子串](src/algorithms/string/longest-common-substring)
   *  `A` [正则表达式匹配](src/algorithms/string/regular-expression-matching)
@@ -101,11 +101,11 @@ _Read this in other languages:_
   * `A` [戴克斯特拉算法](src/algorithms/graph/dijkstra) - 找到图中所有顶点的最短路径
   * `A` [贝尔曼-福特算法](src/algorithms/graph/bellman-ford) - 找到图中所有顶点的最短路径
   * `A` [弗洛伊德算法](src/algorithms/graph/floyd-warshall) - 找到所有顶点对 之间的最短路径
-  * `A` [判圈算法](src/algorithms/graph/detect-cycle) - 对于有向图和无向图 (基于DFS和不相交集的版本) 
-  * `A` [普林演算法](src/algorithms/graph/prim) - 寻找加权无向图的最小生成树 (MST) 
-  * `B` [克鲁斯克尔演算法](src/algorithms/graph/kruskal) - 寻找加权无向图的最小生成树 (MST) 
+  * `A` [判圈算法](src/algorithms/graph/detect-cycle) - 对于有向图和无向图 (基于DFS和不相交集的版本)
+  * `A` [普林演算法](src/algorithms/graph/prim) - 寻找加权无向图的最小生成树 (MST)
+  * `B` [克鲁斯克尔演算法](src/algorithms/graph/kruskal) - 寻找加权无向图的最小生成树 (MST)
   * `A` [拓扑排序](src/algorithms/graph/topological-sorting) - DFS 方法
-  * `A` [关节点](src/algorithms/graph/articulation-points) - Tarjan算法 (基于DFS) 
+  * `A` [关节点](src/algorithms/graph/articulation-points) - Tarjan算法 (基于DFS)
   * `A` [桥](src/algorithms/graph/bridges) - 基于DFS的算法
   * `A` [欧拉回径与一笔画问题](src/algorithms/graph/eulerian-path) - Fleury的算法 - 一次访问每个边
   * `A` [哈密顿图](src/algorithms/graph/hamiltonian-cycle) - 恰好访问每个顶点一次
@@ -116,7 +116,7 @@ _Read this in other languages:_
   * `B` [旋转矩阵](src/algorithms/uncategorized/square-matrix-rotation) - 原地算法
   * `B` [跳跃 游戏](src/algorithms/uncategorized/jump-game) - 回溯, 动态编程 (自上而下+自下而上) 和贪婪的例子
   * `B` [独特(唯一) 路径](src/algorithms/uncategorized/unique-paths) - 回溯, 动态编程和基于Pascal三角形的例子
-  * `B` [雨水收集](src/algorithms/uncategorized/rain-terraces) - 诱捕雨水问题 (动态编程和暴力版本) 
+  * `B` [雨水收集](src/algorithms/uncategorized/rain-terraces) - 诱捕雨水问题 (动态编程和暴力版本)
   * `A` [八皇后问题](src/algorithms/uncategorized/n-queens)
   * `A` [骑士巡逻](src/algorithms/uncategorized/knight-tour)
 

src/algorithms/math/euclidean-algorithm/__test__/euclieanAlgorithm.test.js renamed to src/algorithms/math/euclidean-algorithm/__test__/euclideanAlgorithm.test.js

@@ -1,7 +1,7 @@
 import euclideanAlgorithm from '../euclideanAlgorithm';
 
 describe('euclideanAlgorithm', () => {
-  it('should calculate GCD', () => {
+  it('should calculate GCD recursively', () => {
     expect(euclideanAlgorithm(0, 0)).toBe(0);
     expect(euclideanAlgorithm(2, 0)).toBe(2);
     expect(euclideanAlgorithm(0, 2)).toBe(2);

src/algorithms/math/euclidean-algorithm/__test__/euclideanAlgorithmIterative.test.js

@@ -0,0 +1,26 @@
+import euclideanAlgorithmIterative from '../euclideanAlgorithmIterative';
+
+describe('euclideanAlgorithmIterative', () => {
+  it('should calculate GCD iteratively', () => {
+    expect(euclideanAlgorithmIterative(0, 0)).toBe(0);
+    expect(euclideanAlgorithmIterative(2, 0)).toBe(2);
+    expect(euclideanAlgorithmIterative(0, 2)).toBe(2);
+    expect(euclideanAlgorithmIterative(1, 2)).toBe(1);
+    expect(euclideanAlgorithmIterative(2, 1)).toBe(1);
+    expect(euclideanAlgorithmIterative(6, 6)).toBe(6);
+    expect(euclideanAlgorithmIterative(2, 4)).toBe(2);
+    expect(euclideanAlgorithmIterative(4, 2)).toBe(2);
+    expect(euclideanAlgorithmIterative(12, 4)).toBe(4);
+    expect(euclideanAlgorithmIterative(4, 12)).toBe(4);
+    expect(euclideanAlgorithmIterative(5, 13)).toBe(1);
+    expect(euclideanAlgorithmIterative(27, 13)).toBe(1);
+    expect(euclideanAlgorithmIterative(24, 60)).toBe(12);
+    expect(euclideanAlgorithmIterative(60, 24)).toBe(12);
+    expect(euclideanAlgorithmIterative(252, 105)).toBe(21);
+    expect(euclideanAlgorithmIterative(105, 252)).toBe(21);
+    expect(euclideanAlgorithmIterative(1071, 462)).toBe(21);
+    expect(euclideanAlgorithmIterative(462, 1071)).toBe(21);
+    expect(euclideanAlgorithmIterative(462, -1071)).toBe(21);
+    expect(euclideanAlgorithmIterative(-462, -1071)).toBe(21);
+  });
+});

src/algorithms/math/euclidean-algorithm/euclideanAlgorithm.js

@@ -1,11 +1,15 @@
 /**
+ * Recursive version of Euclidean Algorithm of finding greatest common divisor (GCD).
  * @param {number} originalA
  * @param {number} originalB
  * @return {number}
  */
 export default function euclideanAlgorithm(originalA, originalB) {
+  // Make input numbers positive.
   const a = Math.abs(originalA);
   const b = Math.abs(originalB);
 
+  // To make algorithm work faster instead of subtracting one number from the other
+  // we may use modulo operation.
   return (b === 0) ? a : euclideanAlgorithm(b, a % b);
 }

src/algorithms/math/euclidean-algorithm/euclideanAlgorithmIterative.js

@@ -0,0 +1,20 @@
+/**
+ * Iterative version of Euclidean Algorithm of finding greatest common divisor (GCD).
+ * @param {number} originalA
+ * @param {number} originalB
+ * @return {number}
+ */
+export default function euclideanAlgorithmIterative(originalA, originalB) {
+  // Make input numbers positive.
+  let a = Math.abs(originalA);
+  let b = Math.abs(originalB);
+
+  // Subtract one number from another until both numbers would become the same.
+  // This will be out GCD. Also quit the loop if one of the numbers is zero.
+  while (a && b && a !== b) {
+    [a, b] = a > b ? [a - b, b] : [a, b - a];
+  }
+
+  // Return the number that is not equal to zero since the last subtraction (it will be a GCD).
+  return a || b;
+}

src/algorithms/string/levenshtein-distance/README.md

@@ -50,7 +50,7 @@ to assist natural language translation based on translation memory.
 
 Let’s take a simple example of finding minimum edit distance between 
 strings `ME` and `MY`. Intuitively you already know that minimum edit distance 
-here is `1` operation and this operation. And it is a replacing `E` with `Y`. But 
+here is `1` operation and this operation. And it is replacing `E` with `Y`. But 
 let’s try to formalize it in a form of the algorithm in order to be able to 
 do more complex examples like transforming `Saturday` into `Sunday`.
 
@@ -62,7 +62,7 @@ is being calculated based on three previously possible transformations.
 
 To explain this further let’s draw the following matrix:
 
-![Levenshtein Matrix](https://cdn-images-1.medium.com/max/1600/1*2d46ug_PL5LfeqztckoYGw.jpeg)
+![Levenshtein Matrix](https://cdn-images-1.medium.com/max/1600/1*aTunSUoy0BJyYBVn4tWGrA.png)
 
 - Cell `(0:1)` contains red number 1. It means that we need 1 operation to 
 transform `M` to an empty string. And it is by deleting `M`. This is why this number is red.
@@ -75,12 +75,12 @@ to transform an empty string to `MY`. And it is by inserting `Y` and  `M`.
 - Cell `(1:1)` contains number 0. It means that it costs nothing 
 to transform `M` into `M`.
 - Cell `(1:2)` contains red number 1. It means that we need 1 operation 
-to transform `ME` to `M`. And it is be deleting `E`.
+to transform `ME` to `M`. And it is by deleting `E`.
 - And so on...
 
 This looks easy for such small matrix as ours (it is only `3x3`). But here you
 may find basic concepts that may be applied to calculate all those numbers for
-bigger matrices (let’s say `9x7` one, for `Saturday → Sunday` transformation).
+bigger matrices (let’s say a `9x7` matrix for `Saturday → Sunday` transformation).
 
 According to the formula you only need three adjacent cells `(i-1:j)`, `(i-1:j-1)`, and `(i:j-1)` to
 calculate the number for current cell `(i:j)`. All we need to do is to find the 
@@ -89,24 +89,24 @@ letters in `i`'s row and `j`'s column.
 
 You may clearly see the recursive nature of the problem.
 
-![Levenshtein Matrix](https://cdn-images-1.medium.com/max/2000/1*JdHQ5TeKiDlE-iKK1s_2vw.jpeg)
+![Levenshtein Matrix](https://cdn-images-1.medium.com/max/1600/1*w8UB4DSvBnAK6mBXRGQDjw.png)
 
 Let's draw a decision graph for this problem.
 
-![Minimum Edit Distance Decision Graph](https://cdn-images-1.medium.com/max/1600/1*SGwYUpXH9H1xUeTvJk0e7Q.jpeg)
+![Minimum Edit Distance Decision Graph](https://cdn-images-1.medium.com/max/1600/1*8jD0qvr5B9PwRFM_9z7q9A.png)
 
 You may see a number of overlapping sub-problems on the picture that are marked 
 with red. Also there is no way to reduce the number of operations and make it 
-less then a minimum of those three adjacent cells from the formula. 
+less than a minimum of those three adjacent cells from the formula. 
 
 Also you may notice that each cell number in the matrix is being calculated 
 based on previous ones. Thus the tabulation technique (filling the cache in 
 bottom-up direction) is being applied here.
 
-Applying this principles further we may solve more complicated cases like 
+Applying this principle further we may solve more complicated cases like 
 with `Saturday → Sunday` transformation.
 
-![Levenshtein distance](https://cdn-images-1.medium.com/max/1600/1*fPEHiImYLKxSTUhrGbYq3g.jpeg)
+![Levenshtein distance](https://cdn-images-1.medium.com/max/1600/1*geMdmZcdU1bZbHIoh6KO3Q.png)
 
 ## References
 

src/data-structures/stack/Stack.js

@@ -4,16 +4,16 @@ export default class Stack {
   constructor() {
     // We're going to implement Stack based on LinkedList since these
     // structures are quite similar. Compare push/pop operations of the Stack
-    // with append/deleteTail operations of LinkedList.
+    // with prepend/deleteHead operations of LinkedList.
     this.linkedList = new LinkedList();
   }
 
   /**
    * @return {boolean}
    */
   isEmpty() {
-    // The stack is empty if its linked list doesn't have a tail.
-    return !this.linkedList.tail;
+    // The stack is empty if its linked list doesn't have a head.
+    return !this.linkedList.head;
   }
 
   /**
@@ -25,27 +25,27 @@ export default class Stack {
       return null;
     }
 
-    // Just read the value from the end of linked list without deleting it.
-    return this.linkedList.tail.value;
+    // Just read the value from the start of linked list without deleting it.
+    return this.linkedList.head.value;
   }
 
   /**
    * @param {*} value
    */
   push(value) {
     // Pushing means to lay the value on top of the stack. Therefore let's just add
-    // the new value at the end of the linked list.
-    this.linkedList.append(value);
+    // the new value at the start of the linked list.
+    this.linkedList.prepend(value);
   }
 
   /**
    * @return {*}
    */
   pop() {
-    // Let's try to delete the last node (the tail) from the linked list.
-    // If there is no tail (the linked list is empty) just return null.
-    const removedTail = this.linkedList.deleteTail();
-    return removedTail ? removedTail.value : null;
+    // Let's try to delete the first node (the head) from the linked list.
+    // If there is no head (the linked list is empty) just return null.
+    const removedHead = this.linkedList.deleteHead();
+    return removedHead ? removedHead.value : null;
   }
 
   /**
@@ -54,8 +54,7 @@ export default class Stack {
   toArray() {
     return this.linkedList
       .toArray()
-      .map(linkedListNode => linkedListNode.value)
-      .reverse();
+      .map(linkedListNode => linkedListNode.value);
   }
 
   /**

src/data-structures/stack/__test__/Stack.test.js

@@ -13,7 +13,7 @@ describe('Stack', () => {
     stack.push(1);
     stack.push(2);
 
-    expect(stack.toString()).toBe('1,2');
+    expect(stack.toString()).toBe('2,1');
   });
 
   it('should peek data from stack', () => {
@@ -58,7 +58,7 @@ describe('Stack', () => {
 
     const stringifier = value => `${value.key}:${value.value}`;
 
-    expect(stack.toString(stringifier)).toBe('key1:test1,key2:test2');
+    expect(stack.toString(stringifier)).toBe('key2:test2,key1:test1');
     expect(stack.pop().value).toBe('test2');
     expect(stack.pop().value).toBe('test1');
   });

src/data-structures/tree/avl-tree/AvlTree.js

@@ -21,7 +21,11 @@ export default class AvlTree extends BinarySearchTree {
    * @return {boolean}
    */
   remove(value) {
-    throw new Error(`Can't remove ${value}. Remove method is not implemented yet`);
+    // Do standard BST removal.
+    super.remove(value);
+
+    // Balance the tree starting from the root node.
+    this.balance(this.root);
   }
 
   /**