@raikuxq/alg-ds 1.1.2 → 1.1.5

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

@@ -0,0 +1,234 @@
+"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");
+/**
+ * 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 Error("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,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 Error("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 Error("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 Error("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,85 @@
+"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");
+/**
+ * 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 Error("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 Error("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 Error("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;
+}