tstruct/dist/SortingAlgorithms/SortingAlgorithms.js

Data structures & basic algorithms library

"use strict";
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spread = (this && this.__spread) || function () {
    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
    return ar;
};
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RadixSort = exports.QuickSort = exports.HeapSort = void 0;
var CompareFunction_1 = require("../CompareFunction");
var PriorityQueue_1 = require("../Queue/PriorityQueue");
function HeapSort(elements, getComparisonValue, compareFunction) {
    if (getComparisonValue === void 0) { getComparisonValue = function (e) { return e; }; }
    if (compareFunction === void 0) { compareFunction = CompareFunction_1.ascendingCompareFunction; }
    var result = [];
    var priorityQueue = new PriorityQueue_1.PriorityQueue(getComparisonValue, compareFunction);
    elements.forEach(function (e) { return priorityQueue.enqueue(e); });
    while (!priorityQueue.isEmpty) {
        result.push(priorityQueue.dequeue());
    }
    return result;
}
exports.HeapSort = HeapSort;
function QuickSort(elements, getComparisonValue, compareFunction) {
    if (getComparisonValue === void 0) { getComparisonValue = function (e) { return e; }; }
    if (compareFunction === void 0) { compareFunction = CompareFunction_1.ascendingCompareFunction; }
    var result = __spread(elements);
    var sort = function (arr, start, end) {
        if (start >= end)
            return;
        var pivot = arr[end];
        var i = start - 1;
        for (var j = start; j <= end; j++) {
            if (compareFunction(getComparisonValue(pivot), getComparisonValue(arr[j])) <= 0) {
                i++;
                var tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
        sort(arr, start, i - 1);
        sort(arr, i + 1, end);
    };
    sort(result, 0, elements.length - 1);
    return result;
}
exports.QuickSort = QuickSort;
function RadixSort(elements, getElementValue) {
    var e_1, _a;
    var result = __spread(elements);
    var getDigitAt = function (n, pos) {
        if (pos > 0 && n == 0)
            return undefined;
        if (pos == 0)
            return n % 10;
        return getDigitAt(Math.floor(n / 10), pos - 1);
    };
    var hasDigits = true;
    var digitPos = 0;
    while (hasDigits) {
        hasDigits = false;
        var arr = [];
        try {
            for (var result_1 = (e_1 = void 0, __values(result)), result_1_1 = result_1.next(); !result_1_1.done; result_1_1 = result_1.next()) {
                var e = result_1_1.value;
                var digit = getDigitAt(getElementValue(e), digitPos);
                if (digit != undefined) {
                    hasDigits = true;
                }
                else {
                    digit = 0;
                }
                if (arr[digit] == undefined) {
                    arr[digit] = [];
                }
                arr[digit].push(e);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (result_1_1 && !result_1_1.done && (_a = result_1.return)) _a.call(result_1);
            }
            finally { if (e_1) throw e_1.error; }
        }
        result = [];
        arr.forEach(function (e) {
            e.forEach(function (e) {
                result.push(e);
            });
        });
        digitPos++;
    }
    return result;
}
exports.RadixSort = RadixSort;