Fix then > than typo.

Author: trekhleb

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])){
 consttmp=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{
 letminimumElement=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);
-}elseif(this.comparator.lessThen(currentElement,pivotElement)){
+}elseif(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])){
 consttmp=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{
 returnthis.compare(a,b)===0;
 }
 
-lessThen(a,b){
+lessThan(a,b){
 returnthis.compare(a,b)<0;
 }
 
-greaterThen(a,b){
+greaterThan(a,b){
 returnthis.compare(a,b)>0;
 }
 
-lessThenOrEqual(a,b){
-returnthis.lessThen(a,b)||this.equal(a,b);
+lessThanOrEqual(a,b){
+returnthis.lessThan(a,b)||this.equal(a,b);
 }
 
-greaterThenOrEqual(a,b){
-returnthis.greaterThen(a,b)||this.equal(a,b);
+greaterThanOrEqual(a,b){
+returnthis.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.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();
 });
 });