@raikuxq/alg-ds 1.1.6 → 1.1.7

package/lib/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.d.ts

@@ -0,0 +1,70 @@
+import { FnCompareTwo } from "../../../types/FnCompareTwo";
+import { EnumTreeTraversalType } from "../../../types/EnumTreeTraversalType";
+import IBinaryTree from "../../../types/IBinaryTree";
+import AbstractBinaryTree from "../AbstractBinaryTree/AbstractBinaryTree";
+import BinarySearchNode from "./BinarySearchNode";
+/**
+ * Unbalanced binary search tree implementation
+ */
+export default class BinarySearchTree<T> extends AbstractBinaryTree<T> {
+    /**
+     * Override types
+     */
+    protected _head: BinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    constructor(fnCompare?: FnCompareTwo<T>);
+    /**
+     *
+     * @throws when head is empty
+     */
+    protected checkIsEmpty(): void;
+    /**
+     * Will update left and right links parent with current node
+     */
+    protected updateLeftRightParents(node: BinarySearchNode<T>): void;
+    /**
+     * Will return node instance by its data
+     */
+    protected findNode(value: T): BinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    protected insertToLeaf(createdNode: BinarySearchNode<T>): void;
+    /**
+     * Will join two trees into one   */
+    protected join(treeLeft: BinarySearchNode<T> | null, treeRight: BinarySearchNode<T> | null): BinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    max(): T;
+    /**
+     * @inheritDoc
+     */
+    min(): T;
+    /**
+     * @inheritDoc
+     */
+    insert(value: T): void;
+    /**
+     * @inheritDoc
+     */
+    has(value: T): boolean;
+    /**
+     * @inheritDoc
+     */
+    delete(value: T): void;
+    /**
+     * @inheritDoc
+     */
+    subtree(value: T): IBinaryTree<T>;
+    /**
+     * @inheritDoc
+     */
+    traverse(type: EnumTreeTraversalType, from?: T): Array<T>;
+    /**
+     * Calc max height of the largest branch of the tree
+     */
+    height(): number;
+}

package/lib/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 IsEmptyException_1 = require("../../../exceptions/IsEmptyException");
+/**
+ * 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 IsEmptyException_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/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts"],"names":[],"mappings":"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"}

package/lib/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFuZEJpbmFyeVNlYXJjaE5vZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YS1zdHJ1Y3R1cmVzL0JpbmFyeVRyZWUvUmFuZEJpbmFyeVNlYXJjaFRyZWUvUmFuZEJpbmFyeVNlYXJjaE5vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUVBQW9FO0FBRXBFO0lBQXFELHdDQUFtQjtJQU10RSw4QkFBbUIsV0FBYztRQUFqQyxZQUNFLGtCQUFNLFdBQVcsQ0FBQyxTQUtuQjtRQUpDLEtBQUksQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDO1FBQ2YsS0FBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7UUFDbEIsS0FBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUM7UUFDbkIsS0FBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7O0lBQ3RCLENBQUM7SUFFRCxzQkFBVyxzQ0FBSTthQUFmO1lBQ0UsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBQ3BCLENBQUM7YUFFRCxVQUFnQixLQUFhO1lBQzNCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsc0NBQUk7YUFBZjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBZ0IsS0FBcUM7WUFDbkQsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyx1Q0FBSzthQUFoQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNyQixDQUFDO2FBRUQsVUFBaUIsS0FBcUM7WUFDcEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7UUFDdEIsQ0FBQzs7O09BSkE7SUFNRCxzQkFBVyx3Q0FBTTthQUFqQjtZQUNFLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUN0QixDQUFDO2FBRUQsVUFBa0IsS0FBcUM7WUFDckQsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDdkIsQ0FBQzs7O09BSkE7SUFLSCwyQkFBQztBQUFELENBQUMsQUE3Q0QsQ0FBcUQsMEJBQWdCLEdBNkNwRSJ9

package/lib/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;
+}