@raikuxq/alg-ds 1.1.6 → 1.2.1

package/lib/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.js

@@ -0,0 +1,271 @@
+"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 EnumTreeTraversalType_1 = require("../../../types/EnumTreeTraversalType");
+var AbstractBinaryTree_1 = require("../AbstractBinaryTree/AbstractBinaryTree");
+var BinarySearchNode_1 = require("./BinarySearchNode");
+var Queue_1 = require("../../Queue/Queue");
+var IsAlreadyExistsException_1 = require("../../../exceptions/IsAlreadyExistsException");
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+var CollectionIsEmptyException_1 = require("../../../exceptions/CollectionIsEmptyException");
+/**
+ * Unbalanced binary search tree implementation
+ */
+var BinarySearchTree = /** @class */ (function (_super) {
+    __extends(BinarySearchTree, _super);
+    /**
+     * @inheritDoc
+     */
+    function BinarySearchTree(fnCompare) {
+        var _this = _super.call(this, fnCompare) || this;
+        _this._head = null;
+        return _this;
+    }
+    /**
+     *
+     * @throws when head is empty
+     */
+    BinarySearchTree.prototype.checkIsEmpty = function () {
+        if (this._head === null) {
+            throw new CollectionIsEmptyException_1.default("Tree is empty");
+        }
+    };
+    /**
+     * Will update left and right links parent with current node
+     */
+    BinarySearchTree.prototype.updateLeftRightParents = function (node) {
+        if (node.left && node.left.parent !== node) {
+            node.left.parent = node;
+        }
+        if (node.right && node.right.parent !== node) {
+            node.right.parent = node;
+        }
+    };
+    /**
+     * Will return node instance by its data
+     */
+    BinarySearchTree.prototype.findNode = function (value) {
+        var current = this._head;
+        while (current && current.data !== value) {
+            current = this.compare(current.data, value)
+                ? current.left
+                : current.right;
+        }
+        return current;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.insertToLeaf = function (createdNode) {
+        var parent = null;
+        var current = this._head;
+        while (current) {
+            parent = current;
+            current = this.compare(current.data, createdNode.data)
+                ? current.left
+                : current.right;
+        }
+        createdNode.parent = parent;
+        if (parent === null) {
+            this._head = createdNode;
+        }
+        else {
+            if (this.compare(parent.data, createdNode.data)) {
+                parent.left = createdNode;
+            }
+            else {
+                parent.right = createdNode;
+            }
+        }
+        this._length++;
+    };
+    /**
+     * Will join two trees into one   */
+    BinarySearchTree.prototype.join = function (treeLeft, treeRight) {
+        if (treeLeft === null) {
+            return treeRight;
+        }
+        if (treeRight === null) {
+            return treeLeft;
+        }
+        treeRight.left = this.join(treeLeft, treeRight.left);
+        if (treeRight.left) {
+            this.updateLeftRightParents(treeRight);
+        }
+        return treeRight;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.max = function () {
+        this.checkIsEmpty();
+        var currentNode = this._head;
+        while (currentNode === null || currentNode === void 0 ? void 0 : currentNode.right) {
+            currentNode = currentNode.right;
+        }
+        return currentNode.data;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.min = function () {
+        this.checkIsEmpty();
+        var currentNode = this._head;
+        while (currentNode === null || currentNode === void 0 ? void 0 : currentNode.left) {
+            currentNode = currentNode.left;
+        }
+        return currentNode.data;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.insert = function (value) {
+        if (this.has(value)) {
+            throw new IsAlreadyExistsException_1.default("Node already exists");
+        }
+        var createdNode = new BinarySearchNode_1.default(value);
+        this.insertToLeaf(createdNode);
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.has = function (value) {
+        var current = this.findNode(value);
+        return (current === null || current === void 0 ? void 0 : current.data) === value;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.delete = function (value) {
+        var _this = this;
+        if (!this.has(value)) {
+            throw new IsNotFoundException_1.default("Value does not exist in the tree");
+        }
+        var recursiveDelete = function (node, value) {
+            if (node === null) {
+                return node;
+            }
+            if (node.data === value) {
+                var updatedNode = _this.join(node.left, node.right);
+                if (updatedNode) {
+                    updatedNode.parent = node.parent;
+                }
+                return updatedNode;
+            }
+            else if (_this.compare(node.data, value)) {
+                node.left = recursiveDelete(node.left, value);
+            }
+            else {
+                node.right = recursiveDelete(node.right, value);
+            }
+            _this.updateLeftRightParents(node);
+            return node;
+        };
+        this._head = recursiveDelete(this._head, value);
+        this._length--;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.subtree = function (value) {
+        var tree = new BinarySearchTree();
+        var node = this.findNode(value);
+        var queue = new Queue_1.default();
+        var traverse = [];
+        queue.push(node);
+        while (!queue.isEmpty()) {
+            var currentNode = queue.pop();
+            traverse.push(currentNode);
+            if (currentNode === null || currentNode === void 0 ? void 0 : currentNode.left) {
+                queue.push(currentNode.left);
+            }
+            if (currentNode === null || currentNode === void 0 ? void 0 : currentNode.right) {
+                queue.push(currentNode.right);
+            }
+        }
+        traverse.forEach(function (elem) {
+            if (elem !== null) {
+                tree.insert(elem.data);
+            }
+        });
+        return tree;
+    };
+    /**
+     * @inheritDoc
+     */
+    BinarySearchTree.prototype.traverse = function (type, from) {
+        this.checkIsEmpty();
+        var array = new Array(this.length());
+        var root = from !== undefined ? this.findNode(from) : this._head;
+        var storeInOrder = function (node) {
+            if (node === null) {
+                return;
+            }
+            storeInOrder(node.left);
+            array.push(node.data);
+            storeInOrder(node.right);
+        };
+        var storePostOrder = function (node) {
+            if (node === null) {
+                return;
+            }
+            storeInOrder(node.left);
+            storeInOrder(node.right);
+            array.push(node.data);
+        };
+        var storePreOrder = function (node) {
+            if (node === null) {
+                return;
+            }
+            array.push(node.data);
+            storeInOrder(node.left);
+            storeInOrder(node.right);
+        };
+        switch (type) {
+            case EnumTreeTraversalType_1.EnumTreeTraversalType.InOrder:
+                storeInOrder(root);
+                break;
+            case EnumTreeTraversalType_1.EnumTreeTraversalType.PostOrder:
+                storePostOrder(root);
+                break;
+            case EnumTreeTraversalType_1.EnumTreeTraversalType.PreOrder:
+                storePreOrder(root);
+                break;
+        }
+        return array.filter(function (item) { return item !== undefined; });
+    };
+    /**
+     * Calc max height of the largest branch of the tree
+     */
+    BinarySearchTree.prototype.height = function () {
+        var calcHeight = function (node) {
+            if (node === null)
+                return 0;
+            var left = node.left === null ? -1 : calcHeight(node.left);
+            var right = node.right === null ? -1 : calcHeight(node.right);
+            var max = left > right ? left : right;
+            return max + 1;
+        };
+        if (this._head === null) {
+            return 0;
+        }
+        else {
+            return calcHeight(this._head) + 1;
+        }
+    };
+    return BinarySearchTree;
+}(AbstractBinaryTree_1.default));
+exports.default = BinarySearchTree;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BinarySearchTree.js","sourceRoot":"","sources":["../../../../../src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts"],"names":[],"mappings":"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"}

package/lib/app/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.d.ts

@@ -0,0 +1,16 @@
+import BinarySearchNode from "../BinarySearchTree/BinarySearchNode";
+export default class RandBinarySearchNode<T> extends BinarySearchNode<T> {
+    private _rank;
+    protected _left: RandBinarySearchNode<T> | null;
+    protected _right: RandBinarySearchNode<T> | null;
+    protected _parent: RandBinarySearchNode<T> | null;
+    constructor(initialData: T);
+    get rank(): number;
+    set rank(value: number);
+    get left(): RandBinarySearchNode<T> | null;
+    set left(value: RandBinarySearchNode<T> | null);
+    get right(): RandBinarySearchNode<T> | null;
+    set right(value: RandBinarySearchNode<T> | null);
+    get parent(): RandBinarySearchNode<T> | null;
+    set parent(value: RandBinarySearchNode<T> | null);
+}

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

@@ -0,0 +1,70 @@
+"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 BinarySearchNode_1 = require("../BinarySearchTree/BinarySearchNode");
+var RandBinarySearchNode = /** @class */ (function (_super) {
+    __extends(RandBinarySearchNode, _super);
+    function RandBinarySearchNode(initialData) {
+        var _this = _super.call(this, initialData) || this;
+        _this._rank = 0;
+        _this._left = null;
+        _this._right = null;
+        _this._parent = null;
+        return _this;
+    }
+    Object.defineProperty(RandBinarySearchNode.prototype, "rank", {
+        get: function () {
+            return this._rank;
+        },
+        set: function (value) {
+            this._rank = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RandBinarySearchNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (value) {
+            this._left = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RandBinarySearchNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (value) {
+            this._right = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(RandBinarySearchNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (value) {
+            this._parent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RandBinarySearchNode;
+}(BinarySearchNode_1.default));
+exports.default = RandBinarySearchNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFuZEJpbmFyeVNlYXJjaE5vZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL2RhdGEtc3RydWN0dXJlcy9CaW5hcnlUcmVlL1JhbmRCaW5hcnlTZWFyY2hUcmVlL1JhbmRCaW5hcnlTZWFyY2hOb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlFQUFvRTtBQUVwRTtJQUFxRCx3Q0FBbUI7SUFNdEUsOEJBQW1CLFdBQWM7UUFBakMsWUFDRSxrQkFBTSxXQUFXLENBQUMsU0FLbkI7UUFKQyxLQUFJLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQztRQUNmLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLEtBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDO1FBQ25CLEtBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDOztJQUN0QixDQUFDO0lBRUQsc0JBQVcsc0NBQUk7YUFBZjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBZ0IsS0FBYTtZQUMzQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNyQixDQUFDOzs7T0FKQTtJQU1ELHNCQUFXLHNDQUFJO2FBQWY7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQzthQUVELFVBQWdCLEtBQXFDO1lBQ25ELElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsdUNBQUs7YUFBaEI7WUFDRSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDckIsQ0FBQzthQUVELFVBQWlCLEtBQXFDO1lBQ3BELElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO1FBQ3RCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsd0NBQU07YUFBakI7WUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQzthQUVELFVBQWtCLEtBQXFDO1lBQ3JELElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ3ZCLENBQUM7OztPQUpBO0lBS0gsMkJBQUM7QUFBRCxDQUFDLEFBN0NELENBQXFELDBCQUFnQixHQTZDcEUifQ==

package/lib/app/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree.d.ts

@@ -0,0 +1,57 @@
+import { FnCompareTwo } from "../../../types/FnCompareTwo";
+import RandBinarySearchNode from "./RandBinarySearchNode";
+import BinarySearchTree from "../BinarySearchTree/BinarySearchTree";
+/**
+ * Randomized binary search tree implementation
+ */
+export default class RandBinarySearchTree<T> extends BinarySearchTree<T> {
+    /**
+     * Override types
+     */
+    protected _head: RandBinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    constructor(fnCompare?: FnCompareTwo<T>);
+    /**
+     * Will update node rank by summing left and right subtrees tanks and itself rank (1)
+     */
+    private updateRank;
+    /**
+     * Will set rank and parent attributes and update tree length
+     */
+    private addCreatedNode;
+    /**
+     * Will rotate node to the right side
+     */
+    private rotateNodeRight;
+    /**
+     * Will rotate node to the left side
+     */
+    private rotateNodeLeft;
+    /**
+     * @inheritDoc
+     */
+    protected join(treeLeft: RandBinarySearchNode<T> | null, treeRight: RandBinarySearchNode<T> | null): RandBinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    protected updateLeftRightParents(node: RandBinarySearchNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected insertToRoot(createdNode: RandBinarySearchNode<T>, fromNode?: RandBinarySearchNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    protected insertRandomly(createdNode: RandBinarySearchNode<T>): void;
+    /**
+     * @inheritDoc
+     */
+    insert(value: T): void;
+    /**
+     * @inheritDoc
+     */
+    delete(value: T): void;
+    length(): number;
+}

package/lib/app/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/app/data-structures/BinaryTree/_helpers/createBinaryTree.d.ts

@@ -0,0 +1,6 @@
+import { EnumBinarySearchTreeType } from "../../../types/EnumBinarySearchTreeType";
+import IBinaryTree from "../../../types/IBinaryTree";
+/**
+ * Returns binary tree by type
+ */
+export declare const createBinaryTree: <T>(type: EnumBinarySearchTreeType) => IBinaryTree<T>;