@lucadani7/algonodejs-for-beginners/dist/SortingAlgorithms.js

Just a simple Node.js package with some basic algorithms perfect for people just starting out. It's got easy-to-understand TypeScript versions of stuff like sorting, searching, math with numbers, and messing with strings.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SortingAlgorithms = void 0;
class SortingAlgorithms {
    static bubbleSort(arr, n) {
        for (let i = 0; i < n - 1; ++i) {
            let isSorted = true;
            for (let j = 0; j < n - i - 1; ++j) {
                if (arr[j + 1] > arr[j]) {
                    isSorted = false;
                    let aux = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = aux;
                }
            }
            if (!isSorted) {
                break;
            }
        }
    }
    static insertSort(arr, n) {
        for (let i = 1; i < n; ++i) {
            let value = arr[i];
            let j = i - 1;
            while (j > -1 && arr[j] > value) {
                arr[j + 1] = arr[j];
                --j;
            }
            arr[j + 1] = value;
        }
    }
    static partition(arr, start, end) {
        let pivot = arr[start];
        let i = start - 1;
        let j = end + 1;
        while (true) {
            do {
                ++i;
            } while (arr[i] < pivot);
            do {
                --j;
            } while (arr[j] > pivot);
            if (i >= j) {
                return j;
            }
            let aux = arr[i];
            arr[i] = arr[j];
            arr[j] = aux;
        }
    }
    static randomPartition(arr, start, end) {
        let random = start + Math.floor(Math.random() * (end - start + 1));
        let aux = arr[random];
        arr[random] = arr[start];
        arr[start] = aux;
        return this.partition(arr, start, end);
    }
    static quickSort(arr, start, end) {
        if (start >= end) {
            return;
        }
        let pi = this.randomPartition(arr, start, end);
        this.quickSort(arr, start, pi);
        this.quickSort(arr, pi + 1, end);
    }
    static merge(arr, start, middle, end) {
        const auxArray = new Array(end - start + 1);
        let i = start;
        let j = middle + 1;
        let k = 0;
        while (i <= middle && j <= end) {
            auxArray[k++] = (arr[i] <= arr[j]) ? arr[i++] : arr[j++];
        }
        while (i <= middle) {
            auxArray[k++] = arr[i++];
        }
        while (j <= end) {
            auxArray[k++] = arr[j++];
        }
        for (i = 0; i < k; ++i) {
            arr[start + i] = auxArray[i];
        }
    }
    static mergeSort(arr, start, end) {
        if (start >= end) {
            return;
        }
        const middle = Math.floor((start + end) / 2);
        this.mergeSort(arr, start, middle);
        this.mergeSort(arr, middle + 1, end);
        this.merge(arr, start, middle, end);
    }
    static heapify(arr, pos, n) {
        let largest = pos;
        let left = 2 * pos + 1;
        let right = 2 * pos + 2;
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }
        if (largest !== pos) {
            let aux = arr[pos];
            arr[pos] = arr[largest];
            arr[largest] = aux;
            this.heapify(arr, largest, n);
        }
    }
    static heapSort(arr, n) {
        for (let i = Math.floor(n / 2) - 1; i > -1; --i) {
            this.heapify(arr, i, n);
        }
        for (let i = n - 1; i > 0; --i) {
            let aux = arr[0];
            arr[0] = arr[i];
            arr[i] = aux;
            this.heapify(arr, 0, i);
        }
    }
}
exports.SortingAlgorithms = SortingAlgorithms;