Sort algorithm in Typescript and Javascript

script.ts

const bubbleSort = (arr: Array<number>) => {
  for (let i = 0; i < arr.length; i++) {
    let swapped = false;

    for (let j = 0; j < arr.length - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let min = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = min;

        swapped = true;
      }
    }

    if (!swapped) break;
  }

  return arr;
};

const selectionSort = (arr: Array<number>) => {
  let arrSize = arr.length;

  for (let step = 0; step < arrSize - 1; step++) {
    let minIdx = step;

    for (let i = step + 1; i < arrSize; i++) {
      // To sort in descending order, change > to < in this line.
      // Select the minimum element in each loop.
      if (arr[i] < arr[minIdx]) {
        minIdx = i;
      }
    }

    let temp = arr[step];
    arr[step] = arr[minIdx];
    arr[minIdx] = temp;
  }

  return arr;
};

const insertionSort = (arr: Array<number>) => {
  let arrSize = arr.length;

  for (let step = 1; step < arrSize; step++) {
    let key = arr[step];
    let i = step - 1;

    while (i >= 0 && key < arr[i]) {
      arr[i + 1] = arr[i];
      --i;
    }

    arr[i + 1] = key;
  }

  return arr;
};

const mergeSort = (arr: Array<number>) => {
  if (arr.length <= 1) return arr;

  let mid = Math.floor(arr.length / 2);
  let leftArr = mergeSort(arr.slice(0, mid));
  let rightArr = mergeSort(arr.slice(mid));

  const merge = (leftArr: Array<number>, rightArr: Array<number>) => {
    let leftPointer = 0;
    let rightPointer = 0;

    let result = [];

    while (leftPointer < leftArr.length && rightPointer < rightArr.length) {
      // left < right
      if (leftArr[leftPointer] < rightArr[rightPointer]) {
        result.push(leftArr[leftPointer]);
        leftPointer++;
      } else {
        result.push(rightArr[rightPointer]);
        rightPointer++;
      }
    }

    while (leftPointer < leftArr.length) {
      result.push(leftArr[leftPointer]);
      leftPointer++;
    }

    while (rightPointer < rightArr.length) {
      result.push(rightArr[rightPointer]);
      rightPointer++;
    }

    return result;
  };

  return merge(leftArr, rightArr);
};

const quickSort = (arr: Array<number>) => {
  if (arr.length <= 1) return arr;

  let pivot = arr[0];
  let leftArr = [];
  let rightArr = [];

  for (let i = 1; i < arr.length; i++) {
    arr[i] < pivot ? leftArr.push(arr[i]) : rightArr.push(arr[i]);
  }

  return quickSort(leftArr).concat(pivot, quickSort(rightArr));
};

const counterSort = (arr: Array<number>) => {
  if (arr.length <= 1) return arr;

  const min = Math.min(...arr);
  const max = Math.max(...arr);
  let CreatedArrIndex = min;
  let resultIndex = 0;
  let arrLength = arr.length;
  let count = [];

  for (CreatedArrIndex; CreatedArrIndex <= max; CreatedArrIndex++) {
    count[CreatedArrIndex] = 0;
  }

  for (CreatedArrIndex = 0; CreatedArrIndex < arrLength; CreatedArrIndex++) {
    count[arr[CreatedArrIndex]] += 1;
  }

  for (CreatedArrIndex = 0; CreatedArrIndex <= max; CreatedArrIndex++) {
    while (count[CreatedArrIndex] > 0) {
      arr[resultIndex] = CreatedArrIndex;
      resultIndex++;
      count[CreatedArrIndex]--;
    }
  }

  return arr;
};

const radixSort = (arr: Array<number>) => {
  if (arr.length <= 1) return arr;

  const max = Math.max(...arr);

  const getNumberPosition = (num: number, place: number) =>
    Math.floor(Math.abs(num) / Math.pow(10, place)) % 10;

  for (let i = 0; i < max; i++) {
    let buckets = Array.from({ length: 10 }, () => []);

    for (let j = 0; j < arr.length; j++) {
      buckets[getNumberPosition(arr[j], i)].push(arr[j]); // pushing into buckets
    }

    arr = [].concat(...buckets);
  }

  return arr;
};

const bucketSort = (arr: Array<number>, bucketSize: number = 5) => {
  if (arr.length <= 1) return arr;

  //choose a sort method to sort the buckets
  const insertionSort = (arr: Array<number>) => {
    let arrSize = arr.length;

    for (let step = 1; step < arrSize; step++) {
      let key = arr[step];
      let i = step - 1;

      while (i >= 0 && key < arr[i]) {
        arr[i + 1] = arr[i];
        --i;
      }

      arr[i + 1] = key;
    }

    return arr;
  };

  const min = Math.min(...arr);
  const max = Math.max(...arr);
  let sortedArr = [];

  const bucketCount = Math.floor((max - min) / bucketSize) + 1;
  let buckets = Array.from({ length: bucketCount }, () => []);
  let test = new Array(bucketCount);

  for (let e = 0; e < test.length; e++) {
    test[e] = [];
  }

  // Pushing values to buckets
  arr.forEach(currentVal => {
    buckets[Math.floor((currentVal - min) / bucketSize)].push(currentVal);
  });

  buckets.forEach(bucket => {
    insertionSort(bucket);

    bucket.forEach(element => {
      sortedArr.push(element);
    });
  });

  return sortedArr;
};

const heapSort = (array: Array<number>) => {
  if (array.length <= 1) return array;
  let arr = [...array];
  let length = arr.length;

  const heapify = (arr: Array<number>, index: number) => {
    const leftSide = 2 * index + 1;
    const rightSide = 2 * index + 2;

    let max = index;

    if (leftSide < length && arr[leftSide] > arr[max]) max = leftSide;
    if (rightSide < length && arr[rightSide] > arr[max]) max = rightSide;

    if (max !== index) {
      [arr[max], arr[index]] = [arr[index], arr[max]];
      heapify(arr, max);
    }

    return arr;
  };

  for (let i = Math.floor(length / 2); i >= 0; i -= 1) heapify(arr, i);

  for (let i = arr.length - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]];
    length--;
    heapify(arr, 0);
  }

  return arr;
};

const shellSort = (arr: Array<number>) => {
  let length = arr.length;

  for (let gap = Math.floor(length / 2); gap > 0; gap = Math.floor(gap / 2)) {
    for (let i = gap; i < length; i++) {
      let temp = arr[i];
      let j: number;

      for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
        arr[j] = arr[j - gap];
      }

      arr[j] = temp;
    }
  }

  return arr;
};

const arraysAreEqualTest = (
  arrayOne: Array<number>,
  arrayTwo: Array<number>
) => {
  return (
    arrayOne.length === arrayTwo.length &&
    arrayOne.every(element => {
      return arrayTwo.includes(element);
    })
  );
};

const createArray = (
  arrLength: number,
  min: number = 5,
  max: number = 1000
) => {
  const newArray = [];

  const randomIntFromInterval = (min: number, max: number) =>
    Math.floor(Math.random() * (max - min + 1) + min);

  for (let i = 0; i < arrLength; i++) {
    newArray.push(randomIntFromInterval(min, max));
  }

  return newArray;
};

src: https://www.programiz.com/dsa/sorting-algorithm