@raikuxq/alg-ds 1.1.6 → 1.1.7

package/lib/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree.js

@@ -0,0 +1,235 @@
+"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 RandBinarySearchNode_1 = require("./RandBinarySearchNode");
+var BinarySearchTree_1 = require("../BinarySearchTree/BinarySearchTree");
+var IsAlreadyExistsException_1 = require("../../../exceptions/IsAlreadyExistsException");
+/**
+ * Randomized binary search tree implementation
+ */
+var RandBinarySearchTree = /** @class */ (function (_super) {
+    __extends(RandBinarySearchTree, _super);
+    /**
+     * @inheritDoc
+     */
+    function RandBinarySearchTree(fnCompare) {
+        var _this = _super.call(this, fnCompare) || this;
+        _this._head = null;
+        return _this;
+    }
+    /**
+     * Will update node rank by summing left and right subtrees tanks and itself rank (1)
+     */
+    RandBinarySearchTree.prototype.updateRank = function (node) {
+        var _a, _b;
+        node.rank = (((_a = node.right) === null || _a === void 0 ? void 0 : _a.rank) || 0) + (((_b = node.left) === null || _b === void 0 ? void 0 : _b.rank) || 0) + 1;
+    };
+    /**
+     * Will set rank and parent attributes and update tree length
+     */
+    RandBinarySearchTree.prototype.addCreatedNode = function (node, parentNode) {
+        if (parentNode === void 0) { parentNode = null; }
+        node.rank = 1;
+        if (parentNode !== null) {
+            node.parent = parentNode;
+        }
+        return node;
+    };
+    /**
+     * Will rotate node to the right side
+     */
+    RandBinarySearchTree.prototype.rotateNodeRight = function (node) {
+        var pivot = node.left;
+        if (pivot === null) {
+            return;
+        }
+        node.left = pivot.right;
+        if (pivot.right !== null) {
+            pivot.right.parent = node;
+        }
+        pivot.parent = node.parent;
+        if (node.parent === null) {
+            this._head = pivot;
+        }
+        else {
+            if (node === node.parent.right) {
+                node.parent.right = pivot;
+            }
+            else {
+                node.parent.left = pivot;
+            }
+        }
+        pivot.right = node;
+        node.parent = pivot;
+        this.updateRank(node);
+        this.updateRank(pivot);
+    };
+    /**
+     * Will rotate node to the left side
+     */
+    RandBinarySearchTree.prototype.rotateNodeLeft = function (node) {
+        var pivot = node.right;
+        if (pivot === null) {
+            return;
+        }
+        node.right = pivot.left;
+        if (pivot.left !== null) {
+            pivot.left.parent = node;
+        }
+        pivot.parent = node.parent;
+        if (node.parent === null) {
+            this._head = pivot;
+        }
+        else {
+            if (node === node.parent.left) {
+                node.parent.left = pivot;
+            }
+            else {
+                node.parent.right = pivot;
+            }
+        }
+        pivot.left = node;
+        node.parent = pivot;
+        this.updateRank(node);
+        this.updateRank(pivot);
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.join = function (treeLeft, treeRight) {
+        if (treeLeft === null) {
+            return treeRight;
+        }
+        if (treeRight === null) {
+            return treeLeft;
+        }
+        if (Math.random() < treeLeft.rank / (treeLeft.rank + treeRight.rank)) {
+            treeLeft.right = this.join(treeLeft.right, treeRight);
+            if (treeLeft.right) {
+                this.updateLeftRightParents(treeLeft);
+            }
+            this.updateRank(treeLeft);
+            return treeLeft;
+        }
+        else {
+            treeRight.left = this.join(treeLeft, treeRight.left);
+            if (treeRight.left) {
+                this.updateLeftRightParents(treeRight);
+            }
+            this.updateRank(treeRight);
+            return treeRight;
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.updateLeftRightParents = function (node) {
+        _super.prototype.updateLeftRightParents.call(this, node);
+        this.updateRank(node);
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.insertToRoot = function (createdNode, fromNode) {
+        var _this = this;
+        var recursiveInsert = function (node) {
+            if (_this.compare(node.data, createdNode.data)) {
+                if (node.left === null) {
+                    node.left = _this.addCreatedNode(createdNode, node);
+                }
+                else {
+                    recursiveInsert(node.left);
+                }
+                _this.rotateNodeRight(node);
+            }
+            else {
+                if (node.right === null) {
+                    node.right = _this.addCreatedNode(createdNode, node);
+                }
+                else {
+                    recursiveInsert(node.right);
+                }
+                _this.rotateNodeLeft(node);
+            }
+        };
+        if (this._head === null) {
+            this._head = this.addCreatedNode(createdNode);
+        }
+        else {
+            fromNode ? recursiveInsert(fromNode) : recursiveInsert(this._head);
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.insertRandomly = function (createdNode) {
+        var _this = this;
+        var recursiveInsertRandomly = function (node) {
+            var shouldInsertToRoot = Math.random() < 1 / (node.rank + 1);
+            if (shouldInsertToRoot) {
+                _this.insertToRoot(createdNode, node);
+            }
+            else {
+                node.rank = node.rank + 1;
+                if (_this.compare(node.data, createdNode.data)) {
+                    if (node.left === null) {
+                        node.left = _this.addCreatedNode(createdNode, node);
+                    }
+                    else {
+                        recursiveInsertRandomly(node.left);
+                    }
+                }
+                else {
+                    if (node.right === null) {
+                        node.right = _this.addCreatedNode(createdNode, node);
+                    }
+                    else {
+                        recursiveInsertRandomly(node.right);
+                    }
+                }
+            }
+        };
+        if (this._head === null) {
+            this._head = this.addCreatedNode(createdNode);
+        }
+        else {
+            recursiveInsertRandomly(this._head);
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.insert = function (value) {
+        if (this.has(value)) {
+            throw new IsAlreadyExistsException_1.default("Node already exists");
+        }
+        var createdNode = new RandBinarySearchNode_1.default(value);
+        this.insertRandomly(createdNode);
+    };
+    /**
+     * @inheritDoc
+     */
+    RandBinarySearchTree.prototype.delete = function (value) {
+        _super.prototype.delete.call(this, value);
+        this._length = this.length();
+    };
+    RandBinarySearchTree.prototype.length = function () {
+        var _a;
+        return ((_a = this._head) === null || _a === void 0 ? void 0 : _a.rank) || 0;
+    };
+    return RandBinarySearchTree;
+}(BinarySearchTree_1.default));
+exports.default = RandBinarySearchTree;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/AbstractGraph.d.ts

@@ -0,0 +1,84 @@
+import GraphEdge from "./GraphEdge";
+export default abstract class AbstractGraph<T> {
+    protected _vertices: Map<T, Array<T>>;
+    protected _edges: Array<GraphEdge<T>>;
+    /**
+     * Created empty instance
+     */
+    protected constructor();
+    /**
+     * Find edge by its from and to vertices
+     */
+    protected abstract getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * Get vertices list in array format
+     */
+    protected getVerticesArrayFormat(): Array<T>;
+    /**
+     * Find vertex in vertices list by its data
+     * @throws when vertex was not found
+     */
+    protected tryFindVertex(data: T): T;
+    /**
+     * Update edge weight between from and to vertices
+     */
+    protected updateEdgeWeight(from: T, to: T, weight: number): void;
+    /**
+     * Will remove all vertex relations with others vertices
+     */
+    protected cascadeRemoveVertexRelations(vertexToRemove: T): void;
+    /**
+     * Will remove all vertices edges with vertex to remove
+     */
+    protected cascadeRemoveVertexEdges(vertexToRemove: T): void;
+    /**
+     * Get sum of all graph edges
+     */
+    weight(): number;
+    /**
+     * Get array of vertices
+     */
+    vertices(): Array<T>;
+    /**
+     * Get vertices count
+     */
+    verticesCount(): number;
+    /**
+     * Get edges count
+     */
+    edgesCount(): number;
+    /**
+     * Add vertex
+     * @throws when vertex is already exists
+     */
+    addVertex(data: T): this;
+    /**
+     * Remove vertex
+     * @throws when vertex is already does not exist
+     */
+    removeVertex(data: T): this;
+    /**
+     * Add edge between two vertices
+     */
+    abstract addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * Remove edge between two vertices
+     */
+    abstract removeEdge(from: T, to: T): this;
+    /**
+     * Get vertex neighbors by its data
+     */
+    getVertexNeighbors(data: T): Array<T>;
+    /**
+     * Check if graph has vertex
+     */
+    hasVertex(data: T): boolean;
+    /**
+     * Check if graph has edge between from and to vertices
+     */
+    hasEdge(from: T, to: T): boolean;
+    /**
+     * Get edge weight between from and to vertices
+     */
+    getEdgeWeight(from: T, to: T): number;
+}

package/lib/data-structures/Graph/AbstractGraph.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+var IsAlreadyExistsException_1 = require("../../exceptions/IsAlreadyExistsException");
+var AbstractGraph = /** @class */ (function () {
+    /**
+     * Created empty instance
+     */
+    function AbstractGraph() {
+        this._vertices = new Map();
+        this._edges = new Array();
+    }
+    /**
+     * Get vertices list in array format
+     */
+    AbstractGraph.prototype.getVerticesArrayFormat = function () {
+        return Array.from(this._vertices.keys());
+    };
+    /**
+     * Find vertex in vertices list by its data
+     * @throws when vertex was not found
+     */
+    AbstractGraph.prototype.tryFindVertex = function (data) {
+        var isExists = this._vertices.has(data);
+        if (!isExists) {
+            throw new IsNotFoundException_1.default("Vertex not found");
+        }
+        return data;
+    };
+    /**
+     * Update edge weight between from and to vertices
+     */
+    AbstractGraph.prototype.updateEdgeWeight = function (from, to, weight) {
+        var edge = this.getEdgeByValue(from, to);
+        edge.weight = weight;
+    };
+    /**
+     * Will remove all vertex relations with others vertices
+     */
+    AbstractGraph.prototype.cascadeRemoveVertexRelations = function (vertexToRemove) {
+        var _this = this;
+        this.getVerticesArrayFormat().forEach(function (neighbor) {
+            var neighborVertexNeighbors = _this._vertices.get(neighbor);
+            if (neighborVertexNeighbors) {
+                var neighborVertexFilteredNeighbors = neighborVertexNeighbors.filter(function (newNeighbor) { return newNeighbor !== vertexToRemove; });
+                _this._vertices.set(neighbor, neighborVertexFilteredNeighbors);
+            }
+        });
+    };
+    /**
+     * Will remove all vertices edges with vertex to remove
+     */
+    AbstractGraph.prototype.cascadeRemoveVertexEdges = function (vertexToRemove) {
+        this._edges = this._edges.filter(function (edge) {
+            var shouldBeDeleted = edge.toVertex === vertexToRemove || edge.fromVertex === vertexToRemove;
+            return !shouldBeDeleted;
+        });
+    };
+    /**
+     * Get sum of all graph edges
+     */
+    AbstractGraph.prototype.weight = function () {
+        return this._edges.reduce(function (acc, edge) { return acc + edge.weight; }, 0);
+    };
+    /**
+     * Get array of vertices
+     */
+    AbstractGraph.prototype.vertices = function () {
+        return this.getVerticesArrayFormat().map(function (vertex) { return vertex; });
+    };
+    /**
+     * Get vertices count
+     */
+    AbstractGraph.prototype.verticesCount = function () {
+        return this.vertices().length;
+    };
+    /**
+     * Get edges count
+     */
+    AbstractGraph.prototype.edgesCount = function () {
+        return this._edges.length;
+    };
+    /**
+     * Add vertex
+     * @throws when vertex is already exists
+     */
+    AbstractGraph.prototype.addVertex = function (data) {
+        if (this.hasVertex(data)) {
+            throw new IsAlreadyExistsException_1.default("Vertex is already exist");
+        }
+        this._vertices.set(data, new Array());
+        return this;
+    };
+    /**
+     * Remove vertex
+     * @throws when vertex is already does not exist
+     */
+    AbstractGraph.prototype.removeVertex = function (data) {
+        try {
+            var vertexToRemove = this.tryFindVertex(data);
+            this.cascadeRemoveVertexEdges(vertexToRemove);
+            this.cascadeRemoveVertexRelations(vertexToRemove);
+            this._vertices.delete(vertexToRemove);
+        }
+        catch (e) {
+            throw new IsNotFoundException_1.default("Vertex does not exist already");
+        }
+        return this;
+    };
+    /**
+     * Get vertex neighbors by its data
+     */
+    AbstractGraph.prototype.getVertexNeighbors = function (data) {
+        var vertex = this.tryFindVertex(data);
+        return this._vertices.get(vertex) || [];
+    };
+    /**
+     * Check if graph has vertex
+     */
+    AbstractGraph.prototype.hasVertex = function (data) {
+        return this._vertices.has(data);
+    };
+    /**
+     * Check if graph has edge between from and to vertices
+     */
+    AbstractGraph.prototype.hasEdge = function (from, to) {
+        return Boolean(this._edges.find(function (edge) {
+            return edge.fromVertex === from && edge.toVertex === to;
+        }));
+    };
+    /**
+     * Get edge weight between from and to vertices
+     */
+    AbstractGraph.prototype.getEdgeWeight = function (from, to) {
+        var fromVertex = this.tryFindVertex(from);
+        var toVertex = this.tryFindVertex(to);
+        var edge = this.getEdgeByValue(fromVertex, toVertex);
+        return edge.weight;
+    };
+    return AbstractGraph;
+}());
+exports.default = AbstractGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/DirectedGraph.d.ts

@@ -0,0 +1,24 @@
+import AbstractGraph from "./AbstractGraph";
+import GraphEdge from "./GraphEdge";
+/**
+ * Directed graph - data structure where edges with same pair of vertices are not equal
+ * @example A-B is not the same as B-A
+ */
+export default class DirectedGraph<T> extends AbstractGraph<T> {
+    /**
+     * @inheritDoc
+     */
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * @inheritDoc
+     */
+    addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * @inheritDoc
+     */
+    removeEdge(from: T, to: T): this;
+}

package/lib/data-structures/Graph/DirectedGraph.js

@@ -0,0 +1,86 @@
+"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 AbstractGraph_1 = require("./AbstractGraph");
+var GraphEdge_1 = require("./GraphEdge");
+var IsNotFoundException_1 = require("../../exceptions/IsNotFoundException");
+/**
+ * Directed graph - data structure where edges with same pair of vertices are not equal
+ * @example A-B is not the same as B-A
+ */
+var DirectedGraph = /** @class */ (function (_super) {
+    __extends(DirectedGraph, _super);
+    /**
+     * @inheritDoc
+     */
+    function DirectedGraph() {
+        return _super.call(this) || this;
+    }
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.getEdgeByValue = function (from, to) {
+        var edge = this._edges.find(function (edge) { return edge.fromVertex === from && edge.toVertex === to; });
+        if (!edge) {
+            throw new IsNotFoundException_1.default("Edge not found");
+        }
+        return edge;
+    };
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.addEdge = function (from, to, weight) {
+        var _a;
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex = this.tryFindVertex(to);
+            if (this.hasEdge(fromVertex, toVertex)) {
+                if (typeof weight === "number") {
+                    this.updateEdgeWeight(fromVertex, toVertex, weight);
+                }
+            }
+            else {
+                var edge = new GraphEdge_1.default(fromVertex, toVertex, weight);
+                this._edges.push(edge);
+                (_a = this._vertices.get(fromVertex)) === null || _a === void 0 ? void 0 : _a.push(toVertex);
+            }
+        }
+        catch (_b) {
+            throw new IsNotFoundException_1.default("Edge cannot be added because one of vertices was not found");
+        }
+        return this;
+    };
+    /**
+     * @inheritDoc
+     */
+    DirectedGraph.prototype.removeEdge = function (from, to) {
+        try {
+            var fromVertex = this.tryFindVertex(from);
+            var toVertex_1 = this.tryFindVertex(to);
+            var edgeToRemove_1 = this.getEdgeByValue(fromVertex, toVertex_1);
+            var fromVertexNeighbors = this._vertices.get(fromVertex) || [];
+            var fromNewNeighbors = fromVertexNeighbors.filter(function (vertex) { return toVertex_1 !== vertex; });
+            this._vertices.set(fromVertex, fromNewNeighbors);
+            this._edges = this._edges.filter(function (edge) { return edge !== edgeToRemove_1; });
+        }
+        catch (_a) {
+            throw new IsNotFoundException_1.default("Edge cannot be removed because one of vertices was not found");
+        }
+        return this;
+    };
+    return DirectedGraph;
+}(AbstractGraph_1.default));
+exports.default = DirectedGraph;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/data-structures/Graph/GraphEdge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Graph edge between two vertices
+ */
+export default class GraphEdge<T> {
+    private readonly _fromVertex;
+    private readonly _toVertex;
+    private _weight;
+    /**
+     * Create instance with linked "from" and "to" vertices
+     */
+    constructor(fromVertex: T, toVertex: T, weight?: number);
+    get fromVertex(): T;
+    get toVertex(): T;
+    get weight(): number;
+    set weight(value: number);
+}

package/lib/data-structures/Graph/GraphEdge.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Graph edge between two vertices
+ */
+var GraphEdge = /** @class */ (function () {
+    /**
+     * Create instance with linked "from" and "to" vertices
+     */
+    function GraphEdge(fromVertex, toVertex, weight) {
+        if (weight === void 0) { weight = 0; }
+        this._fromVertex = fromVertex;
+        this._toVertex = toVertex;
+        this._weight = weight;
+    }
+    Object.defineProperty(GraphEdge.prototype, "fromVertex", {
+        get: function () {
+            return this._fromVertex;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphEdge.prototype, "toVertex", {
+        get: function () {
+            return this._toVertex;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GraphEdge.prototype, "weight", {
+        get: function () {
+            return this._weight;
+        },
+        set: function (value) {
+            this._weight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return GraphEdge;
+}());
+exports.default = GraphEdge;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhFZGdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2RhdGEtc3RydWN0dXJlcy9HcmFwaC9HcmFwaEVkZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQTs7R0FFRztBQUNIO0lBS0U7O09BRUc7SUFDSCxtQkFBbUIsVUFBYSxFQUFFLFFBQVcsRUFBRSxNQUFVO1FBQVYsdUJBQUEsRUFBQSxVQUFVO1FBQ3ZELElBQUksQ0FBQyxXQUFXLEdBQUcsVUFBVSxDQUFDO1FBQzlCLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDO1FBQzFCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxzQkFBSSxpQ0FBVTthQUFkO1lBQ0UsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQzFCLENBQUM7OztPQUFBO0lBRUQsc0JBQUksK0JBQVE7YUFBWjtZQUNFLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUN4QixDQUFDOzs7T0FBQTtJQUVELHNCQUFJLDZCQUFNO2FBQVY7WUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQzthQUVELFVBQVcsS0FBYTtZQUN0QixJQUFJLENBQUMsT0FBTyxHQUFHLEtBQUssQ0FBQztRQUN2QixDQUFDOzs7T0FKQTtJQUtILGdCQUFDO0FBQUQsQ0FBQyxBQTdCRCxJQTZCQyJ9

package/lib/data-structures/Graph/UndirectedGraph.d.ts

@@ -0,0 +1,28 @@
+import AbstractGraph from "./AbstractGraph";
+import GraphEdge from "./GraphEdge";
+/**
+ * Undirected graph - data structure where edges with same pair of vertices are equal
+ * @example A-B is same as B-A
+ */
+export default class UndirectedGraph<T> extends AbstractGraph<T> {
+    /**
+     * @inheritDoc
+     */
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+    /**
+     * @inheritDoc
+     */
+    hasEdge(from: T, to: T): boolean;
+    /**
+     * @inheritDoc
+     */
+    addEdge(from: T, to: T, weight?: number): this;
+    /**
+     * @inheritDoc
+     */
+    removeEdge(from: T, to: T): this;
+}