Merge branches 'issue-102-rabin-karp-fix' and 'master' of https://github.com/trekhleb/javascript-algorithms into issue-102-rabin-karp-fix

Author: trekhleb

README.ko-KR.md

@@ -48,7 +48,7 @@ _Read this in other languages:_
 
 ## 알고리즘
 
-알고리즘은 어떤 종료의 문제를 풀 수 있는 정확한 방법이며, 
+알고리즘은 어떤 종류의 문제를 풀 수 있는 정확한 방법이며, 
 일련의 작업을 정확하게 정의해 놓은 규칙들입니다. 
 
 `B` - 입문자, `A` - 숙련자

src/algorithms/graph/kruskal/kruskal.js

@@ -10,7 +10,7 @@ export default function kruskal(graph) {
   // It should fire error if graph is directed since the algorithm works only
   // for undirected graphs.
   if (graph.isDirected) {
-    throw new Error('Prim\'s algorithms works only for undirected graphs');
+    throw new Error('Kruskal\'s algorithms works only for undirected graphs');
   }
 
   // Init new graph that will contain minimum spanning tree of original graph.

src/algorithms/sets/combination-sum/combinationSum.js

@@ -15,20 +15,20 @@ function combinationSumRecursive(
 ) {
   if (remainingSum < 0) {
     // By adding another candidate we've gone below zero.
-    // This would mean that last candidate was not acceptable.
+    // This would mean that the last candidate was not acceptable.
     return finalCombinations;
   }
 
   if (remainingSum === 0) {
-    // In case if after adding the previous candidate out remaining sum
-    // became zero we need to same current combination since it is one
-    // of the answer we're looking for.
+    // If after adding the previous candidate our remaining sum
+    // became zero - we need to save the current combination since it is one
+    // of the answers we're looking for.
     finalCombinations.push(currentCombination.slice());
 
     return finalCombinations;
   }
 
-  // In case if we haven't reached zero yet let's continue to add all
+  // If we haven't reached zero yet let's continue to add all
   // possible candidates that are left.
   for (let candidateIndex = startFrom; candidateIndex < candidates.length; candidateIndex += 1) {
     const currentCandidate = candidates[candidateIndex];

src/data-structures/bloom-filter/README.md

@@ -1,6 +1,6 @@
 # Bloom Filter
 
-A bloom filter is a space-efficient probabilistic 
+A **bloom filter** is a space-efficient probabilistic 
 data structure designed to test whether an element 
 is present in a set. It is designed to be blazingly 
 fast and use minimal memory at the cost of potential

src/data-structures/doubly-linked-list/DoublyLinkedList.js

@@ -213,6 +213,16 @@ export default class DoublyLinkedList {
     return nodes;
   }
 
+  /**
+   * @param {*[]} values - Array of values that need to be converted to linked list.
+   * @return {DoublyLinkedList}
+   */
+  fromArray(values) {
+    values.forEach(value => this.append(value));
+
+    return this;
+  }
+
   /**
    * @param {function} [callback]
    * @return {string}

src/data-structures/doubly-linked-list/__test__/DoublyLinkedList.test.js

@@ -36,6 +36,13 @@ describe('DoublyLinkedList', () => {
     expect(linkedList.toString()).toBe('3,2,1');
   });
 
+  it('should create linked list from array', () => {
+    const linkedList = new DoublyLinkedList();
+    linkedList.fromArray([1, 1, 2, 3, 3, 3, 4, 5]);
+
+    expect(linkedList.toString()).toBe('1,1,2,3,3,3,4,5');
+  });
+
   it('should delete node by value from linked list', () => {
     const linkedList = new DoublyLinkedList();
 

src/data-structures/graph/README.md

@@ -1,6 +1,6 @@
 # Graph
 
-In computer science, a graph is an abstract data type 
+In computer science, a **graph** is an abstract data type 
 that is meant to implement the undirected graph and 
 directed graph concepts from mathematics, specifically
 the field of graph theory

src/data-structures/hash-table/README.md

@@ -1,9 +1,9 @@
 # Hash Table
 
-In computing, a hash table (hash map) is a data 
-structure which implements an associative array 
-abstract data type, a structure that can map keys 
-to values. A hash table uses a hash function to 
+In computing, a **hash table** (hash map) is a data 
+structure which implements an *associative array* 
+abstract data type, a structure that can *map keys 
+to values*. A hash table uses a *hash function* to 
 compute an index into an array of buckets or slots, 
 from which the desired value can be found
 

src/data-structures/heap/README.md

@@ -1,6 +1,6 @@
 # Heap (data-structure)
 
-In computer science, a heap is a specialized tree-based 
+In computer science, a **heap** is a specialized tree-based 
 data structure that satisfies the heap property described
 below.
 

src/data-structures/linked-list/LinkedList.js

@@ -65,7 +65,8 @@ export default class LinkedList {
 
     let deletedNode = null;
 
-    // If the head must be deleted then make 2nd node to be a head.
+    // If the head must be deleted then make next node that is differ
+    // from the head to be a new head.
     while (this.head && this.compare.equal(this.head.value, value)) {
       deletedNode = this.head;
       this.head = this.head.next;
@@ -127,17 +128,17 @@ export default class LinkedList {
    * @return {LinkedListNode}
    */
   deleteTail() {
+    const deletedTail = this.tail;
+
     if (this.head === this.tail) {
       // There is only one node in linked list.
-      const deletedTail = this.tail;
       this.head = null;
       this.tail = null;
 
       return deletedTail;
     }
 
     // If there are many nodes in linked list...
-    const deletedTail = this.tail;
 
     // Rewind to the last node and delete "next" link for the node before the last one.
     let currentNode = this.head;
@@ -174,6 +175,16 @@ export default class LinkedList {
     return deletedHead;
   }
 
+  /**
+   * @param {*[]} values - Array of values that need to be converted to linked list.
+   * @return {LinkedList}
+   */
+  fromArray(values) {
+    values.forEach(value => this.append(value));
+
+    return this;
+  }
+
   /**
    * @return {LinkedListNode[]}
    */

src/data-structures/linked-list/README.md

@@ -1,6 +1,6 @@
 # Linked List
 
-In computer science, a linked list is a linear collection 
+In computer science, a **linked list** is a linear collection 
 of data elements, in which linear order is not given by 
 their physical placement in memory. Instead, each 
 element points to the next. It is a data structure 

src/data-structures/linked-list/__test__/LinkedList.test.js

@@ -184,6 +184,13 @@ describe('LinkedList', () => {
     expect(linkedList.find({ callback: value => value.key === 'test5' })).toBeNull();
   });
 
+  it('should create linked list from array', () => {
+    const linkedList = new LinkedList();
+    linkedList.fromArray([1, 1, 2, 3, 3, 3, 4, 5]);
+
+    expect(linkedList.toString()).toBe('1,1,2,3,3,3,4,5');
+  });
+
   it('should find node by means of custom compare function', () => {
     const comparatorFunction = (a, b) => {
       if (a.customValue === b.customValue) {

src/data-structures/priority-queue/README.md

@@ -1,6 +1,6 @@
 # Priority Queue
 
-In computer science, a priority queue is an abstract data type 
+In computer science, a **priority queue** is an abstract data type 
 which is like a regular queue or stack data structure, but where 
 additionally each element has a "priority" associated with it. 
 In a priority queue, an element with high priority is served before 

src/data-structures/queue/README.md

@@ -1,6 +1,6 @@
 # Queue
 
-In computer science, a queue is a particular kind of abstract data 
+In computer science, a **queue** is a particular kind of abstract data 
 type or collection in which the entities in the collection are 
 kept in order and the principle (or only) operations on the 
 collection are the addition of entities to the rear terminal 

src/data-structures/stack/README.md

@@ -1,6 +1,6 @@
 # Stack
 
-In computer science, a stack is an abstract data type that serves 
+In computer science, a **stack** is an abstract data type that serves 
 as a collection of elements, with two principal operations:
 
 * **push**, which adds an element to the collection, and

src/data-structures/tree/README.md

@@ -6,7 +6,7 @@
 * [Segment Tree](segment-tree) - with min/max/sum range queries examples
 * [Fenwick Tree](fenwick-tree) (Binary Indexed Tree)
 
-In computer science, a tree is a widely used abstract data 
+In computer science, a **tree** is a widely used abstract data 
 type (ADT) — or data structure implementing this ADT—that 
 simulates a hierarchical tree structure, with a root value 
 and subtrees of children with a parent node, represented as 

src/data-structures/tree/avl-tree/README.md

@@ -1,6 +1,6 @@
 # AVL Tree
 
-In computer science, an AVL tree (named after inventors 
+In computer science, an **AVL tree** (named after inventors 
 Adelson-Velsky and Landis) is a self-balancing binary search 
 tree. It was the first such data structure to be invented. 
 In an AVL tree, the heights of the two child subtrees of any

src/data-structures/tree/binary-search-tree/README.md

@@ -1,6 +1,6 @@
 # Binary Search Tree
 
-In computer science, binary search trees (BST), sometimes called 
+In computer science, **binary search trees** (BST), sometimes called 
 ordered or sorted binary trees, are a particular type of container: 
 data structures that store "items" (such as numbers, names etc.) 
 in memory. They allow fast lookup, addition and removal of 

src/data-structures/tree/red-black-tree/README.md

@@ -1,6 +1,6 @@
 # Red–Black Tree
 
-A red–black tree is a kind of self-balancing binary search 
+A **red–black tree** is a kind of self-balancing binary search 
 tree in computer science. Each node of the binary tree has 
 an extra bit, and that bit is often interpreted as the 
 color (red or black) of the node. These color bits are used 
@@ -74,15 +74,15 @@ unlike ordinary binary search trees.
 
 #### Left Right Case (See g, p and x)
 
-![Red Black Tree Balancing](https://www.geeksforgeeks.org/wp-content/uploads/redBlackCase3d.png)
+![Red Black Tree Balancing](https://www.geeksforgeeks.org/wp-content/uploads/redBlackCase3b.png)
 
 #### Right Right Case (See g, p and x)
 
 ![Red Black Tree Balancing](https://www.geeksforgeeks.org/wp-content/uploads/redBlackCase3c.png)
 
 #### Right Left Case (See g, p and x)
 
-![Red Black Tree Balancing](https://www.geeksforgeeks.org/wp-content/uploads/redBlackCase3c.png)
+![Red Black Tree Balancing](https://www.geeksforgeeks.org/wp-content/uploads/redBlackCase3d.png)
 
 ## References
 

src/data-structures/tree/segment-tree/README.md

@@ -1,6 +1,6 @@
 # Segment Tree
 
-In computer science, a segment tree also known as a statistic tree 
+In computer science, a **segment tree** also known as a statistic tree 
 is a tree data structure used for storing information about intervals, 
 or segments. It allows querying which of the stored segments contain 
 a given point. It is, in principle, a static structure; that is, 

src/data-structures/trie/README.md

@@ -1,6 +1,6 @@
 # Trie
 
-In computer science, a trie, also called digital tree and sometimes 
+In computer science, a **trie**, also called digital tree and sometimes 
 radix tree or prefix tree (as they can be searched by prefixes), 
 is a kind of search tree—an ordered tree data structure that is 
 used to store a dynamic set or associative array where the keys