@raikuxq/alg-ds 1.1.6 → 1.1.7

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

@@ -0,0 +1,125 @@
+import AbstractLinkedNode from "./AbstractLinkedNode";
+import ILinkedList from "../../../types/ILinkedList";
+export default abstract class AbstractLinkedList<T> implements ILinkedList<T> {
+    protected readonly _capacity: number;
+    protected _length: number;
+    protected _head: AbstractLinkedNode<T> | null;
+    protected _tail: AbstractLinkedNode<T> | null;
+    /**
+     * Create empty instance
+     */
+    protected constructor(capacity?: number);
+    /**
+     * Will calculate real capacity value
+     * @throws when capacity <= 0
+     */
+    private static calculateCapacity;
+    /**
+     * Will insert node between nodeLeft and nodeRight
+     * @throws when list is full
+     */
+    private insertNodeBetweenTwoNodes;
+    /**
+     * Will remove the node from its neighbors nodes links
+     * @throws when node does not exist
+     */
+    private deleteNode;
+    /**
+     * Will find node by its index
+     * @throws when node was not found
+     */
+    protected getNodeByIndex(index: number): AbstractLinkedNode<T>;
+    /**
+     * Will set links between target, left and right siblings
+     */
+    protected abstract insertNodeBetweenTwoNodesImpl(nodeToPush: AbstractLinkedNode<T>, nodeLeft: AbstractLinkedNode<T>, nodeRight: AbstractLinkedNode<T>): void;
+    /**
+     * Will unset itself links and its neighbors links
+     */
+    protected abstract deleteNodeImpl(node: AbstractLinkedNode<T>): void;
+    /**
+     * Update head link
+     */
+    protected abstract popImpl(): void;
+    /**
+     * Update tail link
+     */
+    protected abstract shiftImpl(): void;
+    /**
+     * Will create empty node instance
+     */
+    protected abstract createNode(value: T): AbstractLinkedNode<T>;
+    /**
+     * Push into start
+     */
+    unshift(value: T): void;
+    /**
+     * Push into end
+     */
+    push(value: T): void;
+    /**
+     * Push from index
+     */
+    pushFromIndex(value: T, fromIndex: number): void;
+    /**
+     * Delete node from list's end
+     */
+    pop(): T;
+    /**
+     * Delete node from list's start and get its data
+     */
+    shift(): T;
+    /**
+     * Delete node from list by index from start
+     */
+    deleteFromIndex(fromIndex: number): T;
+    /**
+     * List length
+     */
+    length(): number;
+    /**
+     * Is list empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Is list full
+     */
+    isFull(): boolean;
+    /**
+     * Check if element exists in list
+     */
+    has(item: T): boolean;
+    /**
+     * Get head element data
+     * @throws when head does not exist
+     */
+    peek(): T;
+    /**
+     * Get tail element data
+     * @throws when tail does not exists
+     */
+    peekFromStart(): T;
+    /**
+     * Get list element by index from start
+     * @throws when element does not exist
+     */
+    peekByIndex(index: number): T;
+    /**
+     * Remove all elements from list
+     */
+    clear(): void;
+    /**
+     * Get elements as an array
+     */
+    getAsArray(): Array<T>;
+    /**
+     * Add elements to list from array
+     * @throws when list is full
+     * */
+    pushFromArray(elements: Array<T>): void;
+    /**
+     * Reverse list nodes links and swap head with tail
+     * @example "4>7>10" will be reversed to "10>7>4"
+     */
+    abstract reverse(): void;
+}

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

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IllegalCapacityException_1 = require("../../../exceptions/IllegalCapacityException");
+var IsFullException_1 = require("../../../exceptions/IsFullException");
+var IsEmptyException_1 = require("../../../exceptions/IsEmptyException");
+var IndexOutOfBoundsException_1 = require("../../../exceptions/IndexOutOfBoundsException");
+var AbstractLinkedList = /** @class */ (function () {
+    /**
+     * Create empty instance
+     */
+    function AbstractLinkedList(capacity) {
+        this._capacity = AbstractLinkedList.calculateCapacity(capacity);
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+    }
+    /**
+     * Will calculate real capacity value
+     * @throws when capacity <= 0
+     */
+    AbstractLinkedList.calculateCapacity = function (capacity) {
+        if (capacity === undefined) {
+            return Number.MAX_VALUE;
+        }
+        if (capacity <= 0) {
+            throw new IllegalCapacityException_1.default("Capacity must be larger than 0");
+        }
+        return capacity;
+    };
+    /**
+     * Will insert node between nodeLeft and nodeRight
+     * @throws when list is full
+     */
+    AbstractLinkedList.prototype.insertNodeBetweenTwoNodes = function (targetNode, leftNode, rightNode) {
+        if (this.isFull()) {
+            throw new IsFullException_1.default("List is full, no more space available");
+        }
+        if (this._head === null) {
+            this._head = targetNode;
+        }
+        if (this._tail === null) {
+            this._tail = targetNode;
+        }
+        if (!leftNode) {
+            leftNode = this._tail;
+        }
+        if (!rightNode) {
+            rightNode = this._head;
+        }
+        this.insertNodeBetweenTwoNodesImpl(targetNode, leftNode, rightNode);
+        this._length++;
+    };
+    /**
+     * Will remove the node from its neighbors nodes links
+     * @throws when node does not exist
+     */
+    AbstractLinkedList.prototype.deleteNode = function (node) {
+        this.deleteNodeImpl(node);
+        this._length--;
+        if (this.isEmpty()) {
+            this.clear();
+        }
+        return node;
+    };
+    /**
+     * Will find node by its index
+     * @throws when node was not found
+     */
+    AbstractLinkedList.prototype.getNodeByIndex = function (index) {
+        var isIndexNotInRange = index < 0 || index > this._length;
+        if (this.isEmpty()) {
+            throw new IsEmptyException_1.default("List is empty");
+        }
+        if (isIndexNotInRange) {
+            throw new IndexOutOfBoundsException_1.default("Index exceed list length");
+        }
+        var currentNode = this._tail;
+        var counter = 0;
+        while (currentNode && counter < index) {
+            currentNode = currentNode.next;
+            counter++;
+        }
+        return currentNode;
+    };
+    /**
+     * Push into start
+     */
+    AbstractLinkedList.prototype.unshift = function (value) {
+        var node = this.createNode(value);
+        this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
+        this._tail = node;
+    };
+    /**
+     * Push into end
+     */
+    AbstractLinkedList.prototype.push = function (value) {
+        var node = this.createNode(value);
+        this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
+        this._head = node;
+    };
+    /**
+     * Push from index
+     */
+    AbstractLinkedList.prototype.pushFromIndex = function (value, fromIndex) {
+        var isIndexNotInRange = fromIndex < 0 || fromIndex > this._length;
+        var shouldPushAsFirst = this.isEmpty() && fromIndex === 0;
+        if (isIndexNotInRange) {
+            throw new IndexOutOfBoundsException_1.default("index must be in range between 0 and list length");
+        }
+        if (shouldPushAsFirst) {
+            this.push(value);
+        }
+        else {
+            var node = this.createNode(value);
+            var nodeLeft = this.getNodeByIndex(fromIndex - 1);
+            var nodeRight = this.getNodeByIndex(fromIndex);
+            this.insertNodeBetweenTwoNodes(node, nodeLeft, nodeRight);
+        }
+    };
+    /**
+     * Delete node from list's end
+     */
+    AbstractLinkedList.prototype.pop = function () {
+        if (this.isEmpty() || this._head === null) {
+            throw new IsEmptyException_1.default("cannot delete because list is empty");
+        }
+        var deletedNode = this.deleteNode(this._head);
+        this.popImpl();
+        return deletedNode.data;
+    };
+    /**
+     * Delete node from list's start and get its data
+     */
+    AbstractLinkedList.prototype.shift = function () {
+        if (this.isEmpty() || this._tail === null) {
+            throw new IsEmptyException_1.default("cannot delete because list is empty");
+        }
+        var deletedNode = this.deleteNode(this._tail);
+        this.shiftImpl();
+        return deletedNode.data;
+    };
+    /**
+     * Delete node from list by index from start
+     */
+    AbstractLinkedList.prototype.deleteFromIndex = function (fromIndex) {
+        var nodeToDelete = this.getNodeByIndex(fromIndex);
+        var deletedNode = this.deleteNode(nodeToDelete);
+        return deletedNode.data;
+    };
+    /**
+     * List length
+     */
+    AbstractLinkedList.prototype.length = function () {
+        return this._length;
+    };
+    /**
+     * Is list empty
+     */
+    AbstractLinkedList.prototype.isEmpty = function () {
+        return this._length === 0;
+    };
+    /**
+     * Is list full
+     */
+    AbstractLinkedList.prototype.isFull = function () {
+        return this._length >= this._capacity;
+    };
+    /**
+     * Check if element exists in list
+     */
+    AbstractLinkedList.prototype.has = function (item) {
+        return this.getAsArray().includes(item);
+    };
+    /**
+     * Get head element data
+     * @throws when head does not exist
+     */
+    AbstractLinkedList.prototype.peek = function () {
+        if (this.isEmpty() || !this._head) {
+            throw new IsEmptyException_1.default("head does not exist");
+        }
+        return this._head.data;
+    };
+    /**
+     * Get tail element data
+     * @throws when tail does not exists
+     */
+    AbstractLinkedList.prototype.peekFromStart = function () {
+        if (this.isEmpty() || !this._tail) {
+            throw new IsEmptyException_1.default("tail does not exist");
+        }
+        return this._tail.data;
+    };
+    /**
+     * Get list element by index from start
+     * @throws when element does not exist
+     */
+    AbstractLinkedList.prototype.peekByIndex = function (index) {
+        var node = this.getNodeByIndex(index);
+        return node.data;
+    };
+    /**
+     * Remove all elements from list
+     */
+    AbstractLinkedList.prototype.clear = function () {
+        this._head = null;
+        this._tail = null;
+        this._length = 0;
+    };
+    /**
+     * Get elements as an array
+     */
+    AbstractLinkedList.prototype.getAsArray = function () {
+        var array = [];
+        var currentNode = this._tail;
+        var counter = 0;
+        while (currentNode && counter < this._length) {
+            if (currentNode)
+                array.push(currentNode.data);
+            currentNode = currentNode.next;
+            counter++;
+        }
+        return array;
+    };
+    /**
+     * Add elements to list from array
+     * @throws when list is full
+     * */
+    AbstractLinkedList.prototype.pushFromArray = function (elements) {
+        var _this = this;
+        elements.forEach(function (element) {
+            if (_this.isFull()) {
+                throw new IsFullException_1.default("List is full, no more space available");
+            }
+            _this.push(element);
+        });
+    };
+    return AbstractLinkedList;
+}());
+exports.default = AbstractLinkedList;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedNode.d.ts

@@ -0,0 +1,20 @@
+export default abstract class AbstractLinkedNode<T> {
+    protected _next: AbstractLinkedNode<T> | null;
+    protected readonly _data: T;
+    /**
+     * Will create empty node
+     */
+    protected constructor(data: T, next?: AbstractLinkedNode<T> | null);
+    /**
+     * Get data of node
+     */
+    get data(): T;
+    /**
+     * Get next node link
+     */
+    get next(): AbstractLinkedNode<T> | null;
+    /**
+     * Set next node link
+     */
+    set next(value: AbstractLinkedNode<T> | null);
+}

package/lib/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedNode.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractLinkedNode = /** @class */ (function () {
+    /**
+     * Will create empty node
+     */
+    function AbstractLinkedNode(data, next) {
+        if (next === void 0) { next = null; }
+        this._data = data;
+        this._next = next;
+    }
+    Object.defineProperty(AbstractLinkedNode.prototype, "data", {
+        /**
+         * Get data of node
+         */
+        get: function () {
+            return this._data;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractLinkedNode.prototype, "next", {
+        /**
+         * Get next node link
+         */
+        get: function () {
+            return this._next;
+        },
+        /**
+         * Set next node link
+         */
+        set: function (value) {
+            this._next = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AbstractLinkedNode;
+}());
+exports.default = AbstractLinkedNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RMaW5rZWROb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9MaW5rZWRMaXN0L0Fic3RyYWN0TGlua2VkTGlzdC9BYnN0cmFjdExpbmtlZE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTtJQUlFOztPQUVHO0lBQ0gsNEJBQXNCLElBQU8sRUFBRSxJQUF5QztRQUF6QyxxQkFBQSxFQUFBLFdBQXlDO1FBQ3RFLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO0lBQ3BCLENBQUM7SUFLRCxzQkFBVyxvQ0FBSTtRQUhmOztXQUVHO2FBQ0g7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQzs7O09BQUE7SUFLRCxzQkFBVyxvQ0FBSTtRQUhmOztXQUVHO2FBQ0g7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQztRQUVEOztXQUVHO2FBQ0gsVUFBZ0IsS0FBbUM7WUFDakQsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BUEE7SUFRSCx5QkFBQztBQUFELENBQUMsQUFoQ0QsSUFnQ0MifQ==

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

@@ -0,0 +1,48 @@
+import IBiDirectIterator from "../../../types/IBiDirectIterator";
+import IBiDirectIterable from "../../../types/IBiDirectIterable";
+import AbstractLinkedList from "../AbstractLinkedList/AbstractLinkedList";
+import DoubleLinkedNode from "./DoubleLinkedNode";
+/**
+ * Linear data structure
+ * Each node has next and prev sibling
+ * Head and tail are linked to each other
+ */
+export default class DoubleLinkedList<T> extends AbstractLinkedList<T> implements IBiDirectIterable<T> {
+    /**
+     * Override types
+     */
+    protected _head: DoubleLinkedNode<T> | null;
+    protected _tail: DoubleLinkedNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    constructor(capacity?: number);
+    /**
+     * @inheritDoc
+     */
+    protected createNode(value: T): DoubleLinkedNode<T>;
+    /**
+     * @inheritDoc
+     */
+    protected insertNodeBetweenTwoNodesImpl(targetNode: DoubleLinkedNode<T>, leftNode: DoubleLinkedNode<T>, rightNode: DoubleLinkedNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected deleteNodeImpl(node: DoubleLinkedNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected popImpl(): void;
+    /**
+     * @inheritDoc
+     */
+    protected shiftImpl(): void;
+    /**
+     * @inheritDoc
+     */
+    reverse(): void;
+    /**
+     * List iterator
+     */
+    iterator(fromIndex?: number): IBiDirectIterator<T>;
+}

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

@@ -0,0 +1,151 @@
+"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 DoubleLinkedNode_1 = require("./DoubleLinkedNode");
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+/**
+ * Linear data structure
+ * Each node has next and prev sibling
+ * Head and tail are linked to each other
+ */
+var DoubleLinkedList = /** @class */ (function (_super) {
+    __extends(DoubleLinkedList, _super);
+    /**
+     * @inheritDoc
+     */
+    function DoubleLinkedList(capacity) {
+        var _this = _super.call(this, capacity) || this;
+        _this._head = null;
+        _this._tail = null;
+        return _this;
+    }
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.createNode = function (value) {
+        return new DoubleLinkedNode_1.default(value);
+    };
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.insertNodeBetweenTwoNodesImpl = function (targetNode, leftNode, rightNode) {
+        targetNode.next = rightNode;
+        targetNode.prev = leftNode;
+        if (targetNode.prev) {
+            targetNode.prev.next = targetNode;
+        }
+        if (targetNode.next) {
+            targetNode.next.prev = targetNode;
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.deleteNodeImpl = function (node) {
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+        node.next = null;
+        node.prev = null;
+    };
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.popImpl = function () {
+        var _a;
+        this._head = ((_a = this._tail) === null || _a === void 0 ? void 0 : _a.prev) || null;
+    };
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.shiftImpl = function () {
+        var _a;
+        this._tail = ((_a = this._head) === null || _a === void 0 ? void 0 : _a.next) || null;
+    };
+    /**
+     * @inheritDoc
+     */
+    DoubleLinkedList.prototype.reverse = function () {
+        var currentNode = this._tail;
+        var i = 0;
+        while (currentNode && i < this._length) {
+            var newPrev = currentNode.next;
+            var newNext = currentNode.prev;
+            currentNode.prev = newPrev;
+            currentNode.next = newNext;
+            i++;
+            currentNode = newNext;
+        }
+        if (currentNode) {
+            this._tail = currentNode.next;
+            this._head = currentNode;
+        }
+    };
+    /**
+     * List iterator
+     */
+    DoubleLinkedList.prototype.iterator = function (fromIndex) {
+        if (fromIndex === void 0) { fromIndex = 0; }
+        var head = this._head;
+        var tail = this._tail;
+        var activeNode = this.getNodeByIndex(fromIndex);
+        var iterator = {
+            /**
+             * @inheritDoc
+             */
+            current: function () {
+                return activeNode.data;
+            },
+            /**
+             * @inheritDoc
+             */
+            hasNext: function () {
+                return Boolean(activeNode.next) && activeNode !== head;
+            },
+            /**
+             * @inheritDoc
+             */
+            hasPrev: function () {
+                return Boolean(activeNode.prev) && activeNode !== tail;
+            },
+            /**
+             * @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;
+            },
+            /**
+             * @inheritDoc
+             * @throws when prev element does not exists
+             */
+            prev: function () {
+                if (!iterator.hasPrev()) {
+                    throw new IsNotFoundException_1.default("Prev element does not exist");
+                }
+                activeNode = activeNode.prev;
+                return activeNode.data;
+            },
+        };
+        return iterator;
+    };
+    return DoubleLinkedList;
+}(AbstractLinkedList_1.default));
+exports.default = DoubleLinkedList;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedNode.d.ts

@@ -0,0 +1,25 @@
+import AbstractLinkedNode from "../AbstractLinkedList/AbstractLinkedNode";
+export default class DoubleLinkedNode<T> extends AbstractLinkedNode<T> {
+    protected _prev: DoubleLinkedNode<T> | null;
+    protected _next: DoubleLinkedNode<T> | null;
+    /**
+     * Will create empty node
+     */
+    constructor(data: T, next?: DoubleLinkedNode<T> | null, prev?: DoubleLinkedNode<T> | null);
+    /**
+     * Set previous node link
+     */
+    set prev(value: DoubleLinkedNode<T> | null);
+    /**
+     * Get previous node link
+     */
+    get prev(): DoubleLinkedNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    set next(value: DoubleLinkedNode<T> | null);
+    /**
+     * @inheritDoc
+     */
+    get next(): DoubleLinkedNode<T> | null;
+}