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[]}
    */