data-structure-typed 1.21.3 → 1.31.0

package/dist/data-structures/binary-tree/bst.js

@@ -1,103 +1,129 @@
 "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) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BST = exports.BSTNode = void 0;
-const types_1 = require("../../types");
-const binary_tree_1 = require("./binary-tree");
-class BSTNode extends binary_tree_1.BinaryTreeNode {
-    constructor(id, val) {
-        super(id, val);
+var types_1 = require("../../types");
+var binary_tree_1 = require("./binary-tree");
+var BSTNode = (function (_super) {
+    __extends(BSTNode, _super);
+    function BSTNode(id, val) {
+        return _super.call(this, id, val) || this;
     }
-}
+    return BSTNode;
+}(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
-class BST extends binary_tree_1.BinaryTree {
-    /**
-     * The constructor function initializes a binary search tree object with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.
-     */
-    constructor(options) {
-        super(options);
-        this._comparator = (a, b) => a - b;
+var BST = (function (_super) {
+    __extends(BST, _super);
+    function BST(options) {
+        var _this = _super.call(this, options) || this;
+        _this._comparator = function (a, b) { return a - b; };
         if (options !== undefined) {
-            const { comparator } = options;
+            var comparator = options.comparator;
             if (comparator !== undefined) {
-                this._comparator = comparator;
+                _this._comparator = comparator;
             }
         }
+        return _this;
     }
-    /**
-     * The function creates a new binary search tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
-     * that will be stored in the node.
-     * @returns a new instance of the BSTNode class with the specified id and value.
-     */
-    createNode(id, val) {
+    BST.prototype.createNode = function (id, val) {
         return new BSTNode(id, val);
-    }
-    /**
-     * The `add` function adds a new node to a binary tree, ensuring that duplicates are not accepted.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add. It
-     * is of type `BinaryTreeNodeId`.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It represents
-     * the value associated with the node.
-     * @returns The function `add` returns the inserted node (`inserted`) if it was successfully added to the binary tree.
-     * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
-     */
-    add(id, val) {
-        // TODO support node as a param
-        let inserted = null;
-        const newNode = this.createNode(id, val);
+    };
+    BST.prototype.add = function (idOrNode, val) {
+        var inserted = null;
+        var newNode = null;
+        if (idOrNode instanceof BSTNode) {
+            newNode = idOrNode;
+        }
+        else if (typeof idOrNode === 'number') {
+            newNode = this.createNode(idOrNode, val);
+        }
+        else if (idOrNode === null) {
+            newNode = null;
+        }
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
-            inserted = (this.root);
+            inserted = this.root;
         }
         else {
-            let cur = this.root;
-            let traversing = true;
+            var cur = this.root;
+            var traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, id) === types_1.CP.eq) {
+                    if (this._compare(cur.id, newNode.id) === types_1.CP.eq) {
                         if (newNode) {
                             cur.val = newNode.val;
                         }
-                        //Duplicates are not accepted.
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, id) === types_1.CP.gt) {
-                        // Traverse left of the node
+                    else if (this._compare(cur.id, newNode.id) === types_1.CP.gt) {
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
                             }
-                            //Add to the left of the current node
                             cur.left = newNode;
                             this._setSize(this.size + 1);
                             traversing = false;
                             inserted = cur.left;
                         }
                         else {
-                            //Traverse the left of the current node
                             if (cur.left)
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, id) === types_1.CP.lt) {
-                        // Traverse right of the node
+                    else if (this._compare(cur.id, newNode.id) === types_1.CP.lt) {
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
                             }
-                            //Add to the right of the current node
                             cur.right = newNode;
                             this._setSize(this.size + 1);
                             traversing = false;
-                            inserted = (cur.right);
+                            inserted = cur.right;
                         }
                         else {
-                            //Traverse the left of the current node
                             if (cur.right)
                                 cur = cur.right;
                         }
@@ -109,28 +135,113 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return inserted;
-    }
-    /**
-     * The function returns the first node in a binary tree that matches the given property name and value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'id'`.
-     * @returns The method is returning either a BinaryTreeNodeId or N (generic type) or null.
-     */
-    get(nodeProperty, propertyName) {
+    };
+    BST.prototype.addMany = function (idsOrNodes, data, isBalanceAdd) {
+        var _this = this;
+        if (isBalanceAdd === void 0) { isBalanceAdd = false; }
+        function hasNoNull(arr) {
+            return arr.indexOf(null) === -1;
+        }
+        if (!isBalanceAdd || !hasNoNull(idsOrNodes)) {
+            return _super.prototype.addMany.call(this, idsOrNodes, data);
+        }
+        var inserted = [];
+        var combinedArr = idsOrNodes.map(function (value, index) { return [value, data === null || data === void 0 ? void 0 : data[index]]; });
+        var sorted = [];
+        function isNodeOrNullTuple(arr) {
+            var e_1, _a;
+            try {
+                for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {
+                    var _b = __read(arr_1_1.value, 1), idOrNode = _b[0];
+                    if (idOrNode instanceof BSTNode)
+                        return true;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (arr_1_1 && !arr_1_1.done && (_a = arr_1.return)) _a.call(arr_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return false;
+        }
+        function isBinaryTreeIdOrNullTuple(arr) {
+            var e_2, _a;
+            try {
+                for (var arr_2 = __values(arr), arr_2_1 = arr_2.next(); !arr_2_1.done; arr_2_1 = arr_2.next()) {
+                    var _b = __read(arr_2_1.value, 1), idOrNode = _b[0];
+                    if (typeof idOrNode === 'number')
+                        return true;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (arr_2_1 && !arr_2_1.done && (_a = arr_2.return)) _a.call(arr_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return false;
+        }
+        var sortedIdsOrNodes = [], sortedData = [];
+        if (isNodeOrNullTuple(combinedArr)) {
+            sorted = combinedArr.sort(function (a, b) { return a[0].id - b[0].id; });
+        }
+        else if (isBinaryTreeIdOrNullTuple(combinedArr)) {
+            sorted = combinedArr.sort(function (a, b) { return a[0] - b[0]; });
+        }
+        else {
+            throw new Error('Invalid input idsOrNodes');
+        }
+        sortedIdsOrNodes = sorted.map(function (_a) {
+            var _b = __read(_a, 1), idOrNode = _b[0];
+            return idOrNode;
+        });
+        sortedData = sorted.map(function (_a) {
+            var _b = __read(_a, 2), val = _b[1];
+            return val;
+        });
+        var recursive = function (arr, data) {
+            if (arr.length === 0)
+                return;
+            var mid = Math.floor((arr.length - 1) / 2);
+            var newNode = _this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
+            inserted.push(newNode);
+            recursive(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
+            recursive(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
+        };
+        var iterative = function () {
+            var n = sorted.length;
+            var stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                var popped = stack.pop();
+                if (popped) {
+                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
+                    if (l <= r) {
+                        var m = l + Math.floor((r - l) / 2);
+                        var newNode = _this.add(sortedIdsOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        inserted.push(newNode);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
+                }
+            }
+        };
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            recursive(sortedIdsOrNodes, sortedData);
+        }
+        else {
+            iterative();
+        }
+        return inserted;
+    };
+    BST.prototype.get = function (nodeProperty, propertyName) {
         var _a;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
-     * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the id of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the id of the leftmost node. If the comparison is
-     * equal, it returns the id of the rightmost node. If there are no nodes in the tree, it returns 0.
-     */
-    lastKey() {
+    };
+    BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === types_1.CP.lt)
             return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
@@ -138,46 +249,36 @@ class BST extends binary_tree_1.BinaryTree {
             return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
-    }
-    /**
-     * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or an
-     * `N` type. It represents the property of the binary tree node that you want to compare with.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for comparison. If not provided, it defaults to `'id'`.
-     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
-     * is set to `true`, the function will return an array with only one node (if
-     * @returns an array of nodes (type N).
-     */
-    getNodes(nodeProperty, propertyName, onlyOne) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    };
+    BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
+        var _this = this;
+        if (propertyName === void 0) { propertyName = 'id'; }
         if (!this.root)
             return [];
-        const result = [];
+        var result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            var _traverse_1 = function (cur) {
+                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
                 if (propertyName === 'id') {
-                    if (this._compare(cur.id, nodeProperty) === types_1.CP.gt)
-                        cur.left && _traverse(cur.left);
-                    if (this._compare(cur.id, nodeProperty) === types_1.CP.lt)
-                        cur.right && _traverse(cur.right);
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.gt)
+                        cur.left && _traverse_1(cur.left);
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.lt)
+                        cur.right && _traverse_1(cur.right);
                 }
                 else {
-                    cur.left && _traverse(cur.left);
-                    cur.right && _traverse(cur.right);
+                    cur.left && _traverse_1(cur.left);
+                    cur.right && _traverse_1(cur.right);
                 }
             };
-            _traverse(this.root);
+            _traverse_1(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
@@ -195,18 +296,9 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return result;
-    }
-    // --- start additional functions
-    /**
-     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
-     * less than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-     * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
-     */
-    lesserSum(beginNode, propertyName) {
+    };
+    BST.prototype.lesserSum = function (beginNode, propertyName) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'id');
@@ -214,9 +306,9 @@ class BST extends binary_tree_1.BinaryTree {
             return 0;
         if (!this.root)
             return 0;
-        const id = beginNode.id;
-        const getSumByPropertyName = (cur) => {
-            let needSum;
+        var id = beginNode.id;
+        var getSumByPropertyName = function (cur) {
+            var needSum;
             switch (propertyName) {
                 case 'id':
                     needSum = cur.id;
@@ -227,45 +319,45 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return needSum;
         };
-        let sum = 0;
+        var sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+            var _traverse_2 = function (cur) {
+                var compared = _this._compare(cur.id, id);
                 if (compared === types_1.CP.eq) {
                     if (cur.right)
-                        sum += this.subTreeSum(cur.right, propertyName);
+                        sum += _this.subTreeSum(cur.right, propertyName);
                     return;
                 }
                 else if (compared === types_1.CP.lt) {
                     if (cur.left)
-                        sum += this.subTreeSum(cur.left, propertyName);
+                        sum += _this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
                     if (cur.right)
-                        _traverse(cur.right);
+                        _traverse_2(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse(cur.left);
+                        _traverse_2(cur.left);
                     else
                         return;
                 }
             };
-            _traverse(this.root);
+            _traverse_2(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    var compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
                         return sum;
                     }
-                    else if (compared === types_1.CP.lt) { // todo maybe a bug
+                    else if (compared === types_1.CP.lt) {
                         if (cur.left)
                             sum += this.subTreeSum(cur.left, propertyName);
                         sum += getSumByPropertyName(cur);
@@ -284,29 +376,18 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return sum;
-    }
-    /**
-     * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
-     * have a greater value than a given node.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be either of type `N` (a generic type),
-     * `BinaryTreeNodeId`, or `null`. It represents the node in the binary tree to which the delta value will be added.
-     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each greater node should be increased.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
-     * 'id'.
-     * @returns a boolean value.
-     */
-    allGreaterNodesAdd(node, delta, propertyName) {
+    };
+    BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (typeof node === 'number')
             node = this.get(node, 'id');
         if (!node)
             return false;
-        const id = node.id;
+        var id = node.id;
         if (!this.root)
             return false;
-        const _sumByPropertyName = (cur) => {
+        var _sumByPropertyName = function (cur) {
             switch (propertyName) {
                 case 'id':
                     cur.id += delta;
@@ -317,26 +398,26 @@ class BST extends binary_tree_1.BinaryTree {
             }
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+            var _traverse_3 = function (cur) {
+                var compared = _this._compare(cur.id, id);
                 if (compared === types_1.CP.gt)
                     _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
-                    _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
-                    _traverse(cur.right);
+                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
+                    _traverse_3(cur.left);
+                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
+                    _traverse_3(cur.right);
             };
-            _traverse(this.root);
+            _traverse_3(this.root);
             return true;
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    var compared = this._compare(cur.id, id);
                     if (compared === types_1.CP.gt)
                         _sumByPropertyName(cur);
                     if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
@@ -347,48 +428,35 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return true;
         }
-    }
-    /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
-    /**
-     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
-     * constructs a balanced binary search tree using either a recursive or iterative approach.
-     * @returns The function `perfectlyBalance()` returns a boolean value.
-     */
-    perfectlyBalance() {
-        const sorted = this.DFS('in', 'node'), n = sorted.length;
+    };
+    BST.prototype.perfectlyBalance = function () {
+        var _this = this;
+        var sorted = this.DFS('in', 'node'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const buildBalanceBST = (l, r) => {
+            var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
-                const m = l + Math.floor((r - l) / 2);
-                const midNode = sorted[m];
-                this.add(midNode.id, midNode.val);
-                buildBalanceBST(l, m - 1);
-                buildBalanceBST(m + 1, r);
+                var m = l + Math.floor((r - l) / 2);
+                var midNode = sorted[m];
+                _this.add(midNode.id, midNode.val);
+                buildBalanceBST_1(l, m - 1);
+                buildBalanceBST_1(m + 1, r);
             };
-            buildBalanceBST(0, n - 1);
+            buildBalanceBST_1(0, n - 1);
             return true;
         }
         else {
-            const stack = [[0, n - 1]];
+            var stack = [[0, n - 1]];
             while (stack.length > 0) {
-                const popped = stack.pop();
+                var popped = stack.pop();
                 if (popped) {
-                    const [l, r] = popped;
+                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
                     if (l <= r) {
-                        const m = l + Math.floor((r - l) / 2);
-                        const midNode = sorted[m];
+                        var m = l + Math.floor((r - l) / 2);
+                        var midNode = sorted[m];
                         this.add(midNode.id, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -397,31 +465,27 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return true;
         }
-    }
-    /**
-     * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
-     * @returns a boolean value.
-     */
-    isAVLBalanced() {
+    };
+    BST.prototype.isAVLBalanced = function () {
         var _a, _b;
         if (!this.root)
             return true;
-        let balanced = true;
+        var balanced = true;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            const _height = (cur) => {
+            var _height_1 = function (cur) {
                 if (!cur)
                     return 0;
-                const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
+                var leftHeight = _height_1(cur.left), rightHeight = _height_1(cur.right);
                 if (Math.abs(leftHeight - rightHeight) > 1)
                     balanced = false;
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            _height(this.root);
+            _height_1(this.root);
         }
         else {
-            const stack = [];
-            let node = this.root, last = null;
-            const depths = new Map();
+            var stack = [];
+            var node = this.root, last = null;
+            var depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -432,8 +496,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            var left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            var right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -447,23 +511,17 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return balanced;
-    }
-    /**
-     * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
-     * greater than, less than, or equal to the second ID.
-     * @param {BinaryTreeNodeId} a - a is a BinaryTreeNodeId, which represents the identifier of a binary tree node.
-     * @param {BinaryTreeNodeId} b - The parameter "b" in the above code refers to a BinaryTreeNodeId.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
-     * than), or CP.eq (equal).
-     */
-    _compare(a, b) {
-        const compared = this._comparator(a, b);
+    };
+    BST.prototype._compare = function (a, b) {
+        var compared = this._comparator(a, b);
         if (compared > 0)
             return types_1.CP.gt;
         else if (compared < 0)
             return types_1.CP.lt;
         else
             return types_1.CP.eq;
-    }
-}
+    };
+    return BST;
+}(binary_tree_1.BinaryTree));
 exports.BST = BST;
+//# sourceMappingURL=bst.js.map