Fix then > than typo.

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 {

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;

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]);

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();

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);

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;
         }
       }

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;

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;
       }
 

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) {
+  lessThanOrEqual(a, b) {
-    return this.lessThen(a, b) || this.equal(a, b);
+    return this.lessThan(a, b) || this.equal(a, b);
   }
 
-  greaterThenOrEqual(a, b) {
+  greaterThanOrEqual(a, b) {
-    return this.greaterThen(a, b) || this.equal(a, b);
+    return this.greaterThan(a, b) || this.equal(a, b);
   }
 
   reverse() {

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.lessThan(1, 2)).toBeTruthy();
-    expect(comparator.lessThen(-1, 2)).toBeTruthy();
+    expect(comparator.lessThan(-1, 2)).toBeTruthy();
-    expect(comparator.lessThen('a', 'b')).toBeTruthy();
+    expect(comparator.lessThan('a', 'b')).toBeTruthy();
-    expect(comparator.lessThen('a', 'ab')).toBeTruthy();
+    expect(comparator.lessThan('a', 'ab')).toBeTruthy();
-    expect(comparator.lessThen(10, 2)).toBeFalsy();
+    expect(comparator.lessThan(10, 2)).toBeFalsy();
-    expect(comparator.lessThenOrEqual(10, 2)).toBeFalsy();
+    expect(comparator.lessThanOrEqual(10, 2)).toBeFalsy();
-    expect(comparator.lessThenOrEqual(1, 1)).toBeTruthy();
+    expect(comparator.lessThanOrEqual(1, 1)).toBeTruthy();
-    expect(comparator.lessThenOrEqual(0, 0)).toBeTruthy();
+    expect(comparator.lessThanOrEqual(0, 0)).toBeTruthy();
-    expect(comparator.greaterThen(0, 0)).toBeFalsy();
+    expect(comparator.greaterThan(0, 0)).toBeFalsy();
-    expect(comparator.greaterThen(10, 0)).toBeTruthy();
+    expect(comparator.greaterThan(10, 0)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(10, 0)).toBeTruthy();
+    expect(comparator.greaterThanOrEqual(10, 0)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(10, 10)).toBeTruthy();
+    expect(comparator.greaterThanOrEqual(10, 10)).toBeTruthy();
-    expect(comparator.greaterThenOrEqual(0, 10)).toBeFalsy();
+    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.lessThan('b', 'aa')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('a', 'aa')).toBeFalsy();
+    expect(comparator.greaterThanOrEqual('a', 'aa')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('aa', 'a')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('aa', 'a')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('a', '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.lessThan('b', 'aa')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('a', 'aa')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('a', 'aa')).toBeTruthy();
-    expect(comparator.greaterThenOrEqual('aa', 'a')).toBeFalsy();
+    expect(comparator.greaterThanOrEqual('aa', 'a')).toBeFalsy();
-    expect(comparator.greaterThenOrEqual('a', 'a')).toBeTruthy();
+    expect(comparator.greaterThanOrEqual('a', 'a')).toBeTruthy();
   });
 });