Merge branch 'master' into master

pltnm239 · May 24, 2018 · 297875e · 297875e
2 parents f2aebe7 + d596e1d
commit 297875e
Show file tree

Hide file tree

Showing 13 changed files with 254 additions and 40 deletions.
diff --git a/README.md b/README.md
@@ -10,6 +10,8 @@ Each algorithm and data structure have its own separate README
 with related explanations and links for further reading and YouTube
 videos.
 
+Read this in other languages: [Chinese](https://github.com/trekhleb/javascript-algorithms/blob/master/README.zh-CN.md)
+
 ## Data Structures
 
 Data structure is a particular way of organizing and storing data in a computer so that it can 
@@ -190,7 +192,7 @@ Below is the list of some of the most used Big O notations and their performance
 | **O(1)**       | 1                            | 1                             | 1                               |
 | **O(log N)**   | 3                            | 6                             | 9                               |
 | **O(N)**       | 10                           | 100                           | 1000                            |
-| **O(N log N)** | 30                           | 60                            | 9000                            |
+| **O(N log N)** | 30                           | 600                           | 9000                            |
 | **O(N^2)**     | 100                          | 10000                         | 1000000                         |
 | **O(2^N)**     | 1024                         | 1.26e+29                      | 1.07e+301                       |
 | **O(N!)**      | 3628800                      | 9.3e+157                      | 4.02e+2567                      |

diff --git a/README.zh-CN.md b/README.zh-CN.md
diff --git a/src/algorithms/search/binary-search/binarySearch.js b/src/algorithms/search/binary-search/binarySearch.js
@@ -22,7 +22,7 @@ export default function binarySearch(sortedArray, seekElement, comparatorCallbac
     }
 
     // Decide which half to choose for seeking next: left or right one.
-    if (comparator.lessThen(sortedArray[middleIndex], seekElement)) {
+    if (comparator.lessThan(sortedArray[middleIndex], seekElement)) {
       // Go to the right half of the array.
       startIndex = middleIndex + 1;
     } else {

diff --git a/src/algorithms/sorting/bubble-sort/BubbleSort.js b/src/algorithms/sorting/bubble-sort/BubbleSort.js
@@ -18,7 +18,7 @@ export default class BubbleSort extends Sort {
         this.callbacks.visitingCallback(array[j]);
 
         // Swap elements if they are in wrong order.
-        if (this.comparator.lessThen(array[j + 1], array[j])) {
+        if (this.comparator.lessThan(array[j + 1], array[j])) {
           const tmp = array[j + 1];
           array[j + 1] = array[j];
           array[j] = tmp;

diff --git a/src/algorithms/sorting/insertion-sort/InsertionSort.js b/src/algorithms/sorting/insertion-sort/InsertionSort.js
@@ -15,7 +15,7 @@ export default class InsertionSort extends Sort {
       // If this is the case then swap that elements.
       while (
         array[currentIndex - 1] &&
-        this.comparator.lessThen(array[currentIndex], array[currentIndex - 1])
+        this.comparator.lessThan(array[currentIndex], array[currentIndex - 1])
       ) {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[currentIndex - 1]);

diff --git a/src/algorithms/sorting/merge-sort/MergeSort.js b/src/algorithms/sorting/merge-sort/MergeSort.js
@@ -31,7 +31,7 @@ export default class MergeSort extends Sort {
       let minimumElement = null;
 
       // Find minimum element of two arrays.
-      if (this.comparator.lessThenOrEqual(leftArray[0], rightArray[0])) {
+      if (this.comparator.lessThanOrEqual(leftArray[0], rightArray[0])) {
         minimumElement = leftArray.shift();
       } else {
         minimumElement = rightArray.shift();

diff --git a/src/algorithms/sorting/quick-sort/QuickSort.js b/src/algorithms/sorting/quick-sort/QuickSort.js
@@ -27,7 +27,7 @@ export default class QuickSort extends Sort {
 
       if (this.comparator.equal(currentElement, pivotElement)) {
         centerArray.push(currentElement);
-      } else if (this.comparator.lessThen(currentElement, pivotElement)) {
+      } else if (this.comparator.lessThan(currentElement, pivotElement)) {
         leftArray.push(currentElement);
       } else {
         rightArray.push(currentElement);

diff --git a/src/algorithms/sorting/selection-sort/SelectionSort.js b/src/algorithms/sorting/selection-sort/SelectionSort.js
@@ -16,7 +16,7 @@ export default class SelectionSort extends Sort {
         // Call visiting callback.
         this.callbacks.visitingCallback(array[j]);
 
-        if (this.comparator.lessThen(array[j], array[minIndex])) {
+        if (this.comparator.lessThan(array[j], array[minIndex])) {
           minIndex = j;
         }
       }

diff --git a/src/algorithms/sorting/shell-sort/ShellSort.js b/src/algorithms/sorting/shell-sort/ShellSort.js
@@ -20,7 +20,7 @@ export default class ShellSort extends Sort {
           this.callbacks.visitingCallback(array[currentIndex]);
 
           // Compare and swap array elements if needed.
-          if (this.comparator.lessThen(array[gapShiftedIndex], array[currentIndex])) {
+          if (this.comparator.lessThan(array[gapShiftedIndex], array[currentIndex])) {
             const tmp = array[currentIndex];
             array[currentIndex] = array[gapShiftedIndex];
             array[gapShiftedIndex] = tmp;

diff --git a/src/algorithms/uncategorized/knight-tour/knightTour.js b/src/algorithms/uncategorized/knight-tour/knightTour.js
@@ -4,7 +4,7 @@
  * @return {number[][]}
  */
 function getPossibleMoves(chessboard, position) {
-  // Generate all knight moves (event those that goes beyond the board).
+  // Generate all knight moves (even those that go beyond the board).
   const possibleMoves = [
     [position[0] - 1, position[1] - 2],
     [position[0] - 2, position[1] - 1],

diff --git a/src/data-structures/heap/MinHeap.js b/src/data-structures/heap/MinHeap.js
@@ -167,7 +167,7 @@ export default class MinHeap {
           leftChild !== null &&
           (
             parentItem === null ||
-            this.compare.lessThen(parentItem, this.heapContainer[indexToRemove])
+            this.compare.lessThan(parentItem, this.heapContainer[indexToRemove])
           )
         ) {
           this.heapifyDown(indexToRemove);
@@ -209,7 +209,7 @@ export default class MinHeap {
 
     while (
       this.hasParent(currentIndex) &&
-      this.compare.lessThen(this.heapContainer[currentIndex], this.parent(currentIndex))
+      this.compare.lessThan(this.heapContainer[currentIndex], this.parent(currentIndex))
     ) {
       this.swap(currentIndex, this.getParentIndex(currentIndex));
       currentIndex = this.getParentIndex(currentIndex);
@@ -228,14 +228,14 @@ export default class MinHeap {
     while (this.hasLeftChild(currentIndex)) {
       if (
         this.hasRightChild(currentIndex) &&
-        this.compare.lessThen(this.rightChild(currentIndex), this.leftChild(currentIndex))
+        this.compare.lessThan(this.rightChild(currentIndex), this.leftChild(currentIndex))
       ) {
         nextIndex = this.getRightChildIndex(currentIndex);
       } else {
         nextIndex = this.getLeftChildIndex(currentIndex);
       }
 
-      if (this.compare.lessThen(this.heapContainer[currentIndex], this.heapContainer[nextIndex])) {
+      if (this.compare.lessThan(this.heapContainer[currentIndex], this.heapContainer[nextIndex])) {
         break;
       }
 

diff --git a/src/utils/comparator/Comparator.js b/src/utils/comparator/Comparator.js
@@ -23,20 +23,20 @@ export default class Comparator {
     return this.compare(a, b) === 0;
   }
 
-  lessThen(a, b) {
+  lessThan(a, b) {
     return this.compare(a, b) < 0;
   }
 
-  greaterThen(a, b) {
+  greaterThan(a, b) {
     return this.compare(a, b) > 0;
   }
 
-  lessThenOrEqual(a, b) {
-    return this.lessThen(a, b) || this.equal(a, b);
+  lessThanOrEqual(a, b) {
+    return this.lessThan(a, b) || this.equal(a, b);
   }
 
-  greaterThenOrEqual(a, b) {
-    return this.greaterThen(a, b) || this.equal(a, b);
+  greaterThanOrEqual(a, b) {
+    return this.greaterThan(a, b) || this.equal(a, b);
   }
 
   reverse() {

diff --git a/src/utils/comparator/__test__/Comparator.test.js b/src/utils/comparator/__test__/Comparator.test.js
@@ -7,19 +7,19 @@ describe('Comparator', () => {
     expect(comparator.equal(0, 0)).toBeTruthy();
     expect(comparator.equal(0, 1)).toBeFalsy();
     expect(comparator.equal('a', 'a')).toBeTruthy();
-    expect(comparator.lessThen(1, 2)).toBeTruthy();
-    expect(comparator.lessThen(-1, 2)).toBeTruthy();
-    expect(comparator.lessThen('a', 'b')).toBeTruthy();
-    expect(comparator.lessThen('a', 'ab')).toBeTruthy();
-    expect(comparator.lessThen(10, 2)).toBeFalsy();
-    expect(comparator.lessThenOrEqual(10, 2)).toBeFalsy();
-    expect(comparator.lessThenOrEqual(1, 1)).toBeTruthy();
-    expect(comparator.lessThenOrEqual(0, 0)).toBeTruthy();
-    expect(comparator.greaterThen(0, 0)).toBeFalsy();
-    expect(comparator.greaterThen(10, 0)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(10, 0)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(10, 10)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(0, 10)).toBeFalsy();
+    expect(comparator.lessThan(1, 2)).toBeTruthy();
+    expect(comparator.lessThan(-1, 2)).toBeTruthy();
+    expect(comparator.lessThan('a', 'b')).toBeTruthy();
+    expect(comparator.lessThan('a', 'ab')).toBeTruthy();
+    expect(comparator.lessThan(10, 2)).toBeFalsy();
+    expect(comparator.lessThanOrEqual(10, 2)).toBeFalsy();
+    expect(comparator.lessThanOrEqual(1, 1)).toBeTruthy();
+    expect(comparator.lessThanOrEqual(0, 0)).toBeTruthy();
+    expect(comparator.greaterThan(0, 0)).toBeFalsy();
+    expect(comparator.greaterThan(10, 0)).toBeTruthy();
+    expect(comparator.greaterThanOrEqual(10, 0)).toBeTruthy();
+    expect(comparator.greaterThanOrEqual(10, 10)).toBeTruthy();
+    expect(comparator.greaterThanOrEqual(0, 10)).toBeFalsy();
   });
 
   it('should compare with custom comparator function', () => {
@@ -33,18 +33,18 @@ describe('Comparator', () => {
 
     expect(comparator.equal('a', 'b')).toBeTruthy();
     expect(comparator.equal('a', '')).toBeFalsy();
-    expect(comparator.lessThen('b', 'aa')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('a', 'aa')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('aa', 'a')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('a', 'a')).toBeTruthy();
+    expect(comparator.lessThan('b', 'aa')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('a', 'aa')).toBeFalsy();
+    expect(comparator.greaterThanOrEqual('aa', 'a')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('a', 'a')).toBeTruthy();
 
     comparator.reverse();
 
     expect(comparator.equal('a', 'b')).toBeTruthy();
     expect(comparator.equal('a', '')).toBeFalsy();
-    expect(comparator.lessThen('b', 'aa')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('a', 'aa')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('aa', 'a')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('a', 'a')).toBeTruthy();
+    expect(comparator.lessThan('b', 'aa')).toBeFalsy();
+    expect(comparator.greaterThanOrEqual('a', 'aa')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('aa', 'a')).toBeFalsy();
+    expect(comparator.greaterThanOrEqual('a', 'a')).toBeTruthy();
   });
 });