@raikuxq/alg-ds 1.1.6 → 1.1.7

package/lib/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedNode.js

@@ -0,0 +1,65 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractLinkedNode_1 = require("../AbstractLinkedList/AbstractLinkedNode");
+var DoubleLinkedNode = /** @class */ (function (_super) {
+    __extends(DoubleLinkedNode, _super);
+    /**
+     * Will create empty node
+     */
+    function DoubleLinkedNode(data, next, prev) {
+        if (next === void 0) { next = null; }
+        if (prev === void 0) { prev = null; }
+        var _this = _super.call(this, data) || this;
+        _this._prev = prev;
+        _this._next = next;
+        return _this;
+    }
+    Object.defineProperty(DoubleLinkedNode.prototype, "prev", {
+        /**
+         * Get previous node link
+         */
+        get: function () {
+            return this._prev;
+        },
+        /**
+         * Set previous node link
+         */
+        set: function (value) {
+            this._prev = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DoubleLinkedNode.prototype, "next", {
+        /**
+         * @inheritDoc
+         */
+        get: function () {
+            return this._next;
+        },
+        /**
+         * @inheritDoc
+         */
+        set: function (value) {
+            this._next = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DoubleLinkedNode;
+}(AbstractLinkedNode_1.default));
+exports.default = DoubleLinkedNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG91YmxlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvTGlua2VkTGlzdC9Eb3VibGVMaW5rZWRMaXN0L0RvdWJsZUxpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0VBQTBFO0FBRTFFO0lBQWlELG9DQUFxQjtJQUlwRTs7T0FFRztJQUNILDBCQUNFLElBQU8sRUFDUCxJQUF1QyxFQUN2QyxJQUF1QztRQUR2QyxxQkFBQSxFQUFBLFdBQXVDO1FBQ3ZDLHFCQUFBLEVBQUEsV0FBdUM7UUFIekMsWUFLRSxrQkFBTSxJQUFJLENBQUMsU0FHWjtRQUZDLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDOztJQUNwQixDQUFDO0lBS0Qsc0JBQVcsa0NBQUk7UUFJZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7UUFaRDs7V0FFRzthQUNILFVBQWdCLEtBQWlDO1lBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUFBO0lBWUQsc0JBQVcsa0NBQUk7UUFJZjs7V0FFRzthQUNIO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7UUFaRDs7V0FFRzthQUNILFVBQWdCLEtBQWlDO1lBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUFBO0lBUUgsdUJBQUM7QUFBRCxDQUFDLEFBNUNELENBQWlELDRCQUFrQixHQTRDbEUifQ==

package/lib/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.d.ts

@@ -0,0 +1,52 @@
+import IIterator from "../../../types/IIterator";
+import IIterable from "../../../types/IIterable";
+import AbstractLinkedList from "../AbstractLinkedList/AbstractLinkedList";
+import SingleLinkedNode from "./SingleLinkedNode";
+/**
+ * Linear data structure
+ * Each node has next
+ * Head's next node is tail
+ */
+export default class SingleLinkedList<T> extends AbstractLinkedList<T> implements IIterable<T> {
+    /**
+     * Override types
+     */
+    protected _head: SingleLinkedNode<T> | null;
+    protected _tail: SingleLinkedNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    constructor(capacity?: number);
+    /**
+     * Find previous sibling of given node
+     */
+    private getPrevNode;
+    /**
+     * @inheritDoc
+     */
+    protected createNode(value: T): SingleLinkedNode<T>;
+    /**
+     * @inheritDoc
+     */
+    protected insertNodeBetweenTwoNodesImpl(targetNode: SingleLinkedNode<T>, leftNode: SingleLinkedNode<T>, rightNode: SingleLinkedNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected deleteNodeImpl(node: SingleLinkedNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected popImpl(): void;
+    /**
+     * @inheritDoc
+     */
+    protected shiftImpl(): void;
+    /**
+     * @inheritDoc
+     */
+    reverse(): void;
+    /**
+     * List iterator
+     */
+    iterator(fromIndex?: number): IIterator<T>;
+}

package/lib/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.js

@@ -0,0 +1,138 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractLinkedList_1 = require("../AbstractLinkedList/AbstractLinkedList");
+var SingleLinkedNode_1 = require("./SingleLinkedNode");
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+/**
+ * Linear data structure
+ * Each node has next
+ * Head's next node is tail
+ */
+var SingleLinkedList = /** @class */ (function (_super) {
+    __extends(SingleLinkedList, _super);
+    /**
+     * @inheritDoc
+     */
+    function SingleLinkedList(capacity) {
+        var _this = _super.call(this, capacity) || this;
+        _this._head = null;
+        _this._tail = null;
+        return _this;
+    }
+    /**
+     * Find previous sibling of given node
+     */
+    SingleLinkedList.prototype.getPrevNode = function (node) {
+        var currentNode = this._tail;
+        while ((currentNode === null || currentNode === void 0 ? void 0 : currentNode.next) !== node) {
+            currentNode = (currentNode === null || currentNode === void 0 ? void 0 : currentNode.next) || null;
+        }
+        return currentNode;
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.createNode = function (value) {
+        return new SingleLinkedNode_1.default(value);
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.insertNodeBetweenTwoNodesImpl = function (targetNode, leftNode, rightNode) {
+        targetNode.next = rightNode;
+        if (leftNode) {
+            leftNode.next = targetNode;
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.deleteNodeImpl = function (node) {
+        this.getPrevNode(node).next = node.next;
+        node.next = null;
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.popImpl = function () {
+        this._head = this.getPrevNode(this._tail);
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.shiftImpl = function () {
+        var _a;
+        this._tail = ((_a = this._head) === null || _a === void 0 ? void 0 : _a.next) || null;
+    };
+    /**
+     * @inheritDoc
+     */
+    SingleLinkedList.prototype.reverse = function () {
+        var currentNode = this._tail;
+        var prevNode = this._head;
+        var index = 0;
+        while (index < this._length) {
+            var next = (currentNode === null || currentNode === void 0 ? void 0 : currentNode.next) || null;
+            if (currentNode) {
+                currentNode.next = prevNode;
+            }
+            index++;
+            prevNode = currentNode;
+            currentNode = next;
+        }
+        if (currentNode) {
+            this._head = currentNode;
+            this._tail = currentNode.next;
+        }
+    };
+    /**
+     * List iterator
+     */
+    SingleLinkedList.prototype.iterator = function (fromIndex) {
+        if (fromIndex === void 0) { fromIndex = 0; }
+        var head = this._head;
+        var activeNode = this.getNodeByIndex(fromIndex);
+        var iterator = {
+            /**
+             * @inheritDoc
+             */
+            current: function () {
+                return activeNode.data;
+            },
+            /**
+             * @inheritDoc
+             */
+            hasNext: function () {
+                return Boolean(activeNode.next) && activeNode !== head;
+            },
+            /**
+             * @inheritDoc
+             * @throws when next element does not exist
+             */
+            next: function () {
+                if (!iterator.hasNext()) {
+                    throw new IsNotFoundException_1.default("Next element does not exist");
+                }
+                activeNode = activeNode.next;
+                return activeNode.data;
+            },
+        };
+        return iterator;
+    };
+    return SingleLinkedList;
+}(AbstractLinkedList_1.default));
+exports.default = SingleLinkedList;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/LinkedList/SingleLinkedList/SingleLinkedNode.d.ts

@@ -0,0 +1,7 @@
+import AbstractLinkedNode from "../AbstractLinkedList/AbstractLinkedNode";
+export default class SingleLinkedNode<T> extends AbstractLinkedNode<T> {
+    /**
+     * @inheritDoc
+     */
+    constructor(data: T, next?: SingleLinkedNode<T> | null);
+}

package/lib/data-structures/LinkedList/SingleLinkedList/SingleLinkedNode.js

@@ -0,0 +1,29 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractLinkedNode_1 = require("../AbstractLinkedList/AbstractLinkedNode");
+var SingleLinkedNode = /** @class */ (function (_super) {
+    __extends(SingleLinkedNode, _super);
+    /**
+     * @inheritDoc
+     */
+    function SingleLinkedNode(data, next) {
+        if (next === void 0) { next = null; }
+        return _super.call(this, data, next) || this;
+    }
+    return SingleLinkedNode;
+}(AbstractLinkedNode_1.default));
+exports.default = SingleLinkedNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2luZ2xlTGlua2VkTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRhLXN0cnVjdHVyZXMvTGlua2VkTGlzdC9TaW5nbGVMaW5rZWRMaXN0L1NpbmdsZUxpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsK0VBQTBFO0FBRTFFO0lBQWlELG9DQUFxQjtJQUNwRTs7T0FFRztJQUNILDBCQUFtQixJQUFPLEVBQUUsSUFBdUM7UUFBdkMscUJBQUEsRUFBQSxXQUF1QztlQUNqRSxrQkFBTSxJQUFJLEVBQUUsSUFBSSxDQUFDO0lBQ25CLENBQUM7SUFDSCx1QkFBQztBQUFELENBQUMsQUFQRCxDQUFpRCw0QkFBa0IsR0FPbEUifQ==

package/lib/data-structures/LoopedArray/LoopedArray.d.ts

@@ -0,0 +1,83 @@
+import IArrayFacade from "../../types/IArrayFacade";
+/**
+ * Linear data structure
+ * Facade above array
+ * After reaching full array new pushed elements will be overwritten over old elements
+ */
+export default class LoopedArray<T> implements IArrayFacade<T> {
+    private readonly _capacity;
+    private _realLength;
+    private _array;
+    /**
+     * Create empty instance
+     */
+    constructor(capacity: number);
+    /**
+     * Push into end
+     */
+    push(value: T): void;
+    /**
+     * Push into start
+     */
+    unshift(value: T): void;
+    /**
+     * Delete node from array's end
+     */
+    pop(): T;
+    /**
+     * Delete node from array's start
+     */
+    shift(): T;
+    /**
+     * Get head element data
+     */
+    peek(): T;
+    /**
+     * Get tail element data
+     */
+    peekFromStart(): T;
+    /**
+     * Get array element by index from start
+     */
+    peekByIndex(index: number): T;
+    /**
+     * Push from index
+     */
+    pushFromIndex(value: T, fromIndex: number): void;
+    /**
+     * Get elements as array
+     */
+    getAsArray(): Array<T>;
+    /**
+     * Check if element exists in array
+     */
+    has(item: T): boolean;
+    /**
+     * Is array empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Is array full
+     */
+    isFull(): boolean;
+    /**
+     * List length
+     */
+    length(): number;
+    /**
+     * Remove all elements from array
+     */
+    clear(): void;
+    /**
+     * Delete node from array by index from start
+     */
+    deleteFromIndex(fromIndex: number): T;
+    /**
+     * Add elements to array from array
+     * */
+    pushFromArray(elements: Array<T>): void;
+    /**
+     * Reverse array nodes links and swap head with tail
+     */
+    reverse(): void;
+}

package/lib/data-structures/LoopedArray/LoopedArray.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IllegalCapacityException_1 = require("../../exceptions/IllegalCapacityException");
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+var IsEmptyException_1 = require("../../exceptions/IsEmptyException");
+/**
+ * Linear data structure
+ * Facade above array
+ * After reaching full array new pushed elements will be overwritten over old elements
+ */
+var LoopedArray = /** @class */ (function () {
+    /**
+     * Create empty instance
+     */
+    function LoopedArray(capacity) {
+        this._realLength = 0;
+        if (capacity <= 0) {
+            throw new IllegalCapacityException_1.default("Capacity must be larger than 0");
+        }
+        this._capacity = capacity;
+        this._array = new Array(0);
+    }
+    /**
+     * Push into end
+     */
+    LoopedArray.prototype.push = function (value) {
+        if (this._realLength % this._capacity === 0) {
+            this._array = new Array(0);
+        }
+        this._realLength++;
+        if (!this.isFull()) {
+            this._array.push(value);
+        }
+        else {
+            var indexToPush = (this._realLength % this._capacity) - 1;
+            this._array.splice(indexToPush, 1, value);
+        }
+    };
+    /**
+     * Push into start
+     */
+    LoopedArray.prototype.unshift = function (value) {
+        if (this._realLength % this._capacity === 0) {
+            this._array = new Array(0);
+        }
+        this._realLength++;
+        if (!this.isFull()) {
+            this._array.unshift(value);
+        }
+        else {
+            this._array.splice(this._capacity - 1);
+            this._array.unshift(value);
+        }
+    };
+    /**
+     * Delete node from array's end
+     */
+    LoopedArray.prototype.pop = function () {
+        if (this.isEmpty()) {
+            throw new IsEmptyException_1.default("cannot delete because array is empty");
+        }
+        this._realLength--;
+        var deletedItem = this._array.pop();
+        if (deletedItem === undefined) {
+            throw new IsNotFoundException_1.default("cannot delete last element because of it does not exists");
+        }
+        return deletedItem;
+    };
+    /**
+     * Delete node from array's start
+     */
+    LoopedArray.prototype.shift = function () {
+        if (this.isEmpty()) {
+            throw new IsEmptyException_1.default("cannot delete because array is empty");
+        }
+        this._realLength--;
+        var deletedItem = this._array.shift();
+        if (deletedItem === undefined) {
+            throw new IsNotFoundException_1.default("cannot delete first element because of it does not exists");
+        }
+        return deletedItem;
+    };
+    /**
+     * Get head element data
+     */
+    LoopedArray.prototype.peek = function () {
+        return this._array[this._array.length - 1];
+    };
+    /**
+     * Get tail element data
+     */
+    LoopedArray.prototype.peekFromStart = function () {
+        return this._array[0];
+    };
+    /**
+     * Get array element by index from start
+     */
+    LoopedArray.prototype.peekByIndex = function (index) {
+        return this._array[index];
+    };
+    /**
+     * Push from index
+     */
+    LoopedArray.prototype.pushFromIndex = function (value, fromIndex) {
+        this._array[fromIndex] = value;
+    };
+    /**
+     * Get elements as array
+     */
+    LoopedArray.prototype.getAsArray = function () {
+        return this._array;
+    };
+    /**
+     * Check if element exists in array
+     */
+    LoopedArray.prototype.has = function (item) {
+        return this._array.includes(item);
+    };
+    /**
+     * Is array empty
+     */
+    LoopedArray.prototype.isEmpty = function () {
+        return this._array.length === 0;
+    };
+    /**
+     * Is array full
+     */
+    LoopedArray.prototype.isFull = function () {
+        return this._array.length >= this._capacity;
+    };
+    /**
+     * List length
+     */
+    LoopedArray.prototype.length = function () {
+        return this._array.length;
+    };
+    /**
+     * Remove all elements from array
+     */
+    LoopedArray.prototype.clear = function () {
+        this._array = new Array(0);
+    };
+    /**
+     * Delete node from array by index from start
+     */
+    LoopedArray.prototype.deleteFromIndex = function (fromIndex) {
+        var deletedElement = this._array[fromIndex];
+        delete this._array[fromIndex];
+        return deletedElement;
+    };
+    /**
+     * Add elements to array from array
+     * */
+    LoopedArray.prototype.pushFromArray = function (elements) {
+        var _this = this;
+        elements.forEach(function (element) {
+            _this.push(element);
+        });
+    };
+    /**
+     * Reverse array nodes links and swap head with tail
+     */
+    LoopedArray.prototype.reverse = function () {
+        this._array = this._array.reverse();
+    };
+    return LoopedArray;
+}());
+exports.default = LoopedArray;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Queue/Queue.d.ts

@@ -0,0 +1,50 @@
+import ILinearStorage from "../../types/ILinearStorage";
+/**
+ * FIFO data structure
+ */
+export default class Queue<T> implements ILinearStorage<T> {
+    private readonly _list;
+    /**
+     * Create a queue instance
+     */
+    constructor(capacity?: number);
+    /**
+     * Get first element in queue (without deleting)
+     * @throws when list is empty
+     */
+    peek(): T;
+    /**
+     * Add element to queue
+     * @throws when list is full
+     */
+    push(item: T): void;
+    /**
+     * Delete first element in queue
+     * @throws when list is empty
+     */
+    pop(): T;
+    /**
+     * Check if element exists in list
+     */
+    has(item: T): boolean;
+    /**
+     * Is queue empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Is stack full
+     */
+    isFull(): boolean;
+    /**
+     * Remove all elements in queue
+     */
+    clear(): void;
+    /**
+     * Queue length
+     */
+    length(): number;
+    /**
+     * Reverse queue
+     */
+    reverse(): void;
+}