data-structure-typed 1.18.6 → 1.18.8

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

@@ -38,8 +38,16 @@ exports.AbstractBinaryTree = exports.AbstractBinaryTreeNode = void 0;
 var utils_1 = require("../../utils");
 var types_1 = require("../types");
 var AbstractBinaryTreeNode = /** @class */ (function () {
+    /**
+     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * for the binary tree node.
+     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of times the
+     * value `val` appears in the binary tree node. If the `count` parameter is not provided, it defaults to 1.
+     */
     function AbstractBinaryTreeNode(id, val, count) {
-        this._familyPosition = types_1.FamilyPosition.ROOT;
         this._count = 1;
         this._height = 0;
         this._id = id;
@@ -60,8 +68,8 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         get: function () {
             return this._val;
         },
-        set: function (v) {
-            this._val = v;
+        set: function (value) {
+            this._val = value;
         },
         enumerable: false,
         configurable: true
@@ -73,7 +81,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.LEFT;
             }
             this._left = v;
         },
@@ -87,7 +94,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.RIGHT;
             }
             this._right = v;
         },
@@ -104,16 +110,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
-        get: function () {
-            return this._familyPosition;
-        },
-        set: function (v) {
-            this._familyPosition = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(AbstractBinaryTreeNode.prototype, "count", {
         get: function () {
             return this._count;
@@ -134,26 +130,71 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    AbstractBinaryTreeNode.prototype.swapLocation = function (swapNode) {
-        var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = this._createNode(swapNode.id, val);
+    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
+        get: function () {
+            var that = this;
+            if (that.parent) {
+                if (that.parent.left === that) {
+                    if (that.left || that.right) {
+                        return types_1.FamilyPosition.ROOT_LEFT;
+                    }
+                    else {
+                        return types_1.FamilyPosition.LEFT;
+                    }
+                }
+                else if (that.parent.right === that) {
+                    if (that.left || that.right) {
+                        return types_1.FamilyPosition.ROOT_RIGHT;
+                    }
+                    else {
+                        return types_1.FamilyPosition.RIGHT;
+                    }
+                }
+                else {
+                    return types_1.FamilyPosition.MAL_NODE;
+                }
+            }
+            else {
+                if (that.left || that.right) {
+                    return types_1.FamilyPosition.ROOT;
+                }
+                else {
+                    return types_1.FamilyPosition.ISOLATED;
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * The function swaps the location of two nodes in a binary tree.
+     * @param {FAMILY} destNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
+     * @returns the `swapNode` object after swapping its properties with the properties of `this` object.
+     */
+    AbstractBinaryTreeNode.prototype.swapLocation = function (destNode) {
+        var val = destNode.val, count = destNode.count, height = destNode.height, id = destNode.id;
+        var tempNode = this.createNode(id, val, count);
+        tempNode.height = height;
         if (tempNode instanceof AbstractBinaryTreeNode) {
-            tempNode.val = val;
-            tempNode.count = count;
-            tempNode.height = height;
-            swapNode.id = this.id;
-            swapNode.val = this.val;
-            swapNode.count = this.count;
-            swapNode.height = this.height;
+            // TODO should we consider the left, right children?
+            destNode.id = this.id;
+            destNode.val = this.val;
+            destNode.count = this.count;
+            destNode.height = this.height;
             this.id = tempNode.id;
             this.val = tempNode.val;
             this.count = tempNode.count;
             this.height = tempNode.height;
         }
-        return swapNode;
+        return destNode;
     };
+    /**
+     * The `clone` function returns a new instance of the `FAMILY` class with the same `id`, `val`, and `count` properties.
+     * @returns The `clone()` method is returning a new instance of the `FAMILY` class with the same `id`, `val`, and
+     * `count` values as the current instance.
+     */
     AbstractBinaryTreeNode.prototype.clone = function () {
-        return this._createNode(this.id, this.val, this.count);
+        return this.createNode(this.id, this.val, this.count);
     };
     return AbstractBinaryTreeNode;
 }());
@@ -173,13 +214,13 @@ var AbstractBinaryTree = /** @class */ (function () {
         this._visitedLeftSum = [];
         this._autoIncrementId = false;
         this._maxId = -1;
-        this._isDuplicatedVal = false;
+        this._isMergeDuplicatedVal = true;
         this._root = null;
         this._size = 0;
         this._count = 0;
         if (options !== undefined) {
-            var _a = options.loopType, loopType = _a === void 0 ? types_1.LoopType.ITERATIVE : _a, _b = options.autoIncrementId, autoIncrementId = _b === void 0 ? false : _b, _c = options.isDuplicatedVal, isDuplicatedVal = _c === void 0 ? false : _c;
-            this._isDuplicatedVal = isDuplicatedVal;
+            var _a = options.loopType, loopType = _a === void 0 ? types_1.LoopType.ITERATIVE : _a, _b = options.autoIncrementId, autoIncrementId = _b === void 0 ? false : _b, _c = options.isMergeDuplicatedVal, isMergeDuplicatedVal = _c === void 0 ? true : _c;
+            this._isMergeDuplicatedVal = isMergeDuplicatedVal;
             this._autoIncrementId = autoIncrementId;
             this._loopType = loopType;
         }
@@ -240,9 +281,9 @@ var AbstractBinaryTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "isDuplicatedVal", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "isMergeDuplicatedVal", {
         get: function () {
-            return this._isDuplicatedVal;
+            return this._isMergeDuplicatedVal;
         },
         enumerable: false,
         configurable: true
@@ -317,7 +358,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             return;
         };
         var inserted;
-        var needInsert = val !== null ? this._createNode(id, val !== null && val !== void 0 ? val : id, count) : null;
+        var needInsert = val !== null ? this.createNode(id, val, count) : null;
         var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
@@ -333,7 +374,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this._setRoot(val !== null ? this._createNode(id, val !== null && val !== void 0 ? val : id, count) : null);
+            this._setRoot(val !== null ? this.createNode(id, val, count) : null);
             if (needInsert !== null) {
                 this._setSize(1);
                 this._setCount(count);
@@ -343,12 +384,13 @@ var AbstractBinaryTree = /** @class */ (function () {
         return inserted;
     };
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {N | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
+     * either a node object (`N`) or `null`.
+     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
+     * child.
+     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
+     * `undefined` in certain cases.
      */
     AbstractBinaryTree.prototype.addTo = function (newNode, parent) {
         var _a, _b;
@@ -356,7 +398,6 @@ var AbstractBinaryTree = /** @class */ (function () {
             if (parent.left === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.LEFT;
                 }
                 parent.left = newNode;
                 if (newNode !== null) {
@@ -368,7 +409,6 @@ var AbstractBinaryTree = /** @class */ (function () {
             else if (parent.right === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                 }
                 parent.right = newNode;
                 if (newNode !== null) {
@@ -395,13 +435,14 @@ var AbstractBinaryTree = /** @class */ (function () {
     AbstractBinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
         var _c;
+        // TODO not sure addMany not be run multi times
         var inserted = [];
         var map = new Map();
-        if (!this._isDuplicatedVal) {
+        if (this.isMergeDuplicatedVal) {
             try {
                 for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
-                    var i = data_1_1.value;
-                    map.set(i, ((_c = map.get(i)) !== null && _c !== void 0 ? _c : 0) + 1);
+                    var nodeOrId = data_1_1.value;
+                    map.set(nodeOrId, ((_c = map.get(nodeOrId)) !== null && _c !== void 0 ? _c : 0) + 1);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -414,53 +455,49 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
         try {
             for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
-                var item = data_2_1.value;
+                var nodeOrId = data_2_1.value;
+                if (nodeOrId instanceof AbstractBinaryTreeNode) {
+                    inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+                    continue;
+                }
+                if (nodeOrId === null) {
+                    inserted.push(this.add(NaN, null, 0));
+                    continue;
+                }
                 // TODO will this cause an issue?
-                var count = this._isDuplicatedVal ? 1 : map.get(item);
-                if (item instanceof AbstractBinaryTreeNode) {
-                    inserted.push(this.add(item.id, item.val, item.count));
+                var count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
+                var newId = void 0;
+                if (typeof nodeOrId === 'number') {
+                    newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
                 }
-                else if (typeof item === 'number') {
-                    if (!this._autoIncrementId) {
-                        if (!this._isDuplicatedVal) {
-                            if (map.get(item) !== undefined) {
-                                inserted.push(this.add(item, item, count));
-                                map.delete(item);
-                            }
+                else if (nodeOrId instanceof Object) {
+                    if (this.autoIncrementId) {
+                        newId = this.maxId + 1;
+                    }
+                    else {
+                        if (Object.keys(nodeOrId).includes('id')) {
+                            newId = nodeOrId.id;
                         }
                         else {
-                            inserted.push(this.add(item, item, 1));
+                            console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
+                            continue;
                         }
                     }
                 }
-                else if (item instanceof Object) {
-                    if (!this._isDuplicatedVal) {
-                        if (map.has(item)) {
-                            var newId = void 0;
-                            if (!this._autoIncrementId) {
-                                if (Object.keys(item).includes('id')) {
-                                    newId = item.id;
-                                }
-                                else {
-                                    console.warn('Object value must has an id property when the autoIncrementId is false');
-                                    break;
-                                }
-                            }
-                            else {
-                                newId = this.maxId + 1;
-                                this._setMaxId(newId);
-                            }
-                            inserted.push(this.add(newId, item, count));
-                            map.delete(item);
-                        }
-                    }
-                    else {
-                        inserted.push(this.add(++this._maxId, item, 1));
+                else {
+                    console.warn(nodeOrId, " is not added");
+                    continue;
+                }
+                if (this.isMergeDuplicatedVal) {
+                    if (map.has(nodeOrId)) {
+                        inserted.push(this.add(newId, nodeOrId, count));
+                        map.delete(nodeOrId);
                     }
                 }
-                else if (item === null) {
-                    inserted.push(this.add(Number.MAX_SAFE_INTEGER, item, 0));
+                else {
+                    inserted.push(this.add(newId, nodeOrId, 1));
                 }
+                this._setMaxId(newId);
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -484,62 +521,76 @@ var AbstractBinaryTree = /** @class */ (function () {
         return data.length === this.addMany(data).length;
     };
     /**
-     * The function removes a node from a binary tree and returns information about the deleted node.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to remove.
-     * It is of type `BinaryTreeNodeId`.
+     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * node that needs to be balanced.
+     * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
-     * not be decremented and the overall count of the binary tree will not be updated. If `
-     * @returns An array of objects is being returned. Each object in the array has two properties: "deleted" and
-     * "needBalanced". The "deleted" property contains the deleted node or undefined if no node was deleted. The
-     * "needBalanced" property is always null.
+     * not be taken into account when removing it. If `ignoreCount` is set to `false
+     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    AbstractBinaryTree.prototype.remove = function (id, ignoreCount) {
-        var nodes = this.getNodes(id, 'id', true);
-        var node = nodes[0];
-        if (!node)
-            node = undefined;
-        else if (node.count > 1 && !ignoreCount) {
-            node.count--;
+    AbstractBinaryTree.prototype.remove = function (nodeOrId, ignoreCount) {
+        var bstDeletedResult = [];
+        if (!this.root)
+            return bstDeletedResult;
+        var curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        if (!curr)
+            return bstDeletedResult;
+        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        var needBalanced = null, orgCurrent = curr;
+        if (curr.count > 1 && !ignoreCount) {
+            curr.count--;
             this._setCount(this.count - 1);
         }
-        else if (node instanceof AbstractBinaryTreeNode) {
-            var _a = __read(this.getSubTreeSizeAndCount(node), 2), subSize = _a[0], subCount = _a[1];
-            switch (node.familyPosition) {
-                case 0:
-                    this._setSize(this.size - subSize);
-                    this._setCount(this.count - subCount);
-                    node = undefined;
-                    break;
-                case 1:
-                    if (node.parent) {
-                        this._setSize(this.size - subSize);
-                        this._setCount(this.count - subCount);
-                        node.parent.left = null;
+        else {
+            if (!curr.left) {
+                if (!parent) {
+                    if (curr.right !== undefined)
+                        this._setRoot(curr.right);
+                }
+                else {
+                    var fp = curr.familyPosition;
+                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                        parent.left = curr.right;
                     }
-                    break;
-                case 2:
-                    if (node.parent) {
-                        this._setSize(this.size - subSize);
-                        this._setCount(this.count - subCount);
-                        node.parent.right = null;
+                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                        parent.right = curr.right;
                     }
-                    break;
+                    needBalanced = parent;
+                }
+            }
+            else {
+                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                if (leftSubTreeRightMost) {
+                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    orgCurrent = curr.swapLocation(leftSubTreeRightMost);
+                    if (parentOfLeftSubTreeMax) {
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                        else
+                            parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        needBalanced = parentOfLeftSubTreeMax;
+                    }
+                }
             }
+            this._setSize(this.size - 1);
+            this._setCount(this.count - orgCurrent.count);
         }
-        return [{ deleted: node, needBalanced: null }];
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        return bstDeletedResult;
     };
     /**
-     * The function calculates the depth of a binary tree node by traversing its parent nodes.
-     * @param node - N - This is the node for which we want to calculate the depth. It is a generic type,
-     * meaning it can represent any type of data that we want to store in the node.
-     * @returns The depth of the given binary tree node.
+     * The function calculates the depth of a node in a binary tree.
+     * @param {N | BinaryTreeNodeId | null} beginRoot - The `beginRoot` parameter can be one of the following:
+     * @returns the depth of the given node or binary tree.
      */
-    AbstractBinaryTree.prototype.getDepth = function (node) {
+    AbstractBinaryTree.prototype.getDepth = function (beginRoot) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
         var depth = 0;
-        while (node.parent) {
+        while (beginRoot === null || beginRoot === void 0 ? void 0 : beginRoot.parent) {
             depth++;
-            node = node.parent;
+            beginRoot = beginRoot.parent;
         }
         return depth;
     };
@@ -554,6 +605,8 @@ var AbstractBinaryTree = /** @class */ (function () {
     AbstractBinaryTree.prototype.getHeight = function (beginRoot) {
         var _a, _b, _c;
         beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
         if (!beginRoot)
             return -1;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -742,24 +795,28 @@ var AbstractBinaryTree = /** @class */ (function () {
         return result;
     };
     /**
-     * The `getLeftMost` function returns the leftmost node in a binary tree, either recursively or iteratively using tail
-     * recursion optimization.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
-     * | null`. It represents the starting node from which to find the leftmost node in a binary tree. If no node is
-     * provided, the function will use the root node of the binary tree.
-     * @returns The `getLeftMost` function returns the leftmost node in a binary tree.
+     * The `getLeftMost` function returns the leftmost node in a binary tree, starting from a specified node or the root if
+     * no node is specified.
+     * @param {N | BinaryTreeNodeId | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
+     * generic type representing a node in a binary tree), `BinaryTreeNodeId` (a type representing the ID of a binary tree
+     * node), or `null`.
+     * @returns The function `getLeftMost` returns the leftmost node in a binary tree. If the `beginRoot` parameter is
+     * provided, it starts the traversal from that node. If `beginRoot` is not provided or is `null`, it starts the
+     * traversal from the root of the binary tree. If there are no nodes in the binary tree, it returns `null`.
      */
-    AbstractBinaryTree.prototype.getLeftMost = function (node) {
-        node = node !== null && node !== void 0 ? node : this.root;
-        if (!node)
-            return node;
+    AbstractBinaryTree.prototype.getLeftMost = function (beginRoot) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
+        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+        if (!beginRoot)
+            return beginRoot;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_2 = function (cur) {
                 if (!cur.left)
                     return cur;
                 return _traverse_2(cur.left);
             };
-            return _traverse_2(node);
+            return _traverse_2(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
@@ -768,7 +825,7 @@ var AbstractBinaryTree = /** @class */ (function () {
                     return cur;
                 return _traverse_3.cont(cur.left);
             });
-            return _traverse_3(node);
+            return _traverse_3(beginRoot);
         }
     };
     /**
@@ -802,15 +859,12 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The `isBST` function checks if a binary tree is a binary search tree.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
-     * | null`. It represents the root node of the binary search tree (BST) that we want to check for validity. If no node
-     * is provided, the function will default to using the root node of the BST instance that
-     * @returns The `isBST` function returns a boolean value. It returns `true` if the binary tree is a valid binary search
-     * tree, and `false` otherwise.
+     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @returns a boolean value.
      */
-    AbstractBinaryTree.prototype.isBST = function (node) {
-        node = node !== null && node !== void 0 ? node : this.root;
+    AbstractBinaryTree.prototype.isBSTByRooted = function (node) {
+        // TODO there is a bug
         if (!node)
             return true;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -840,6 +894,15 @@ var AbstractBinaryTree = /** @class */ (function () {
             return true;
         }
     };
+    /**
+     * The function checks if a binary tree is a binary search tree.
+     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
+     * search tree (BST).
+     * @returns a boolean value.
+     */
+    AbstractBinaryTree.prototype.isBST = function (node) {
+        return this.isBSTByRooted(this.root);
+    };
     /**
      * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
      * traversal.
@@ -887,6 +950,8 @@ var AbstractBinaryTree = /** @class */ (function () {
      */
     AbstractBinaryTree.prototype.subTreeSum = function (subTreeRoot, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return 0;
         var sum = 0;
@@ -928,17 +993,21 @@ var AbstractBinaryTree = /** @class */ (function () {
         return sum;
     };
     /**
-     * The function `subTreeAdd` adds a specified delta value to a property of each node in a binary tree.
-     * @param subTreeRoot - The `subTreeRoot` parameter is the root node of the subtree where the values will be modified.
+     * The function `subTreeAdd` adds a delta value to a specified property of each node in a subtree.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
+     * tree or the ID of a binary tree node. It can also be `null` if there is no subtree root.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each node in the subtree should be increased or decreased.
+     * each node in the subtree should be incremented or decremented.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` that should be modified. It defaults to `'id'` if not provided.
-     * @returns a boolean value, which is `true`.
+     * specifies the property of the binary tree node that should be modified. It can be either 'id' or 'count'. If no
+     * value is provided for `propertyName`, it defaults to 'id'.
+     * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.subTreeAdd = function (subTreeRoot, delta, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return false;
         var _addByProperty = function (cur) {
@@ -981,7 +1050,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * represents either a node or a property name. If a node is provided, the breadth-first search algorithm will be
      * performed starting from that node. If a property name is provided, the breadth-first search algorithm will be
      * performed starting from the root node
-     * @returns an object of type `AbstractResultsByProperty<N>`.
+     * @returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1009,7 +1078,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * either the name of a property in the `BinaryTreeNode` object or the value of the `id` property in the
      * `BinaryTreeNode` object. This parameter is used to accumulate the results based on the specified property name. If
      * no value
-     * @returns an object of type `AbstractResultsByProperty<N>`.
+     * @returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1103,7 +1172,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * can be either a `BinaryTreeNode` property name or the string `'id'`. If a property name is provided, the function
      * will accumulate results based on that property. If no property name is provided, the function will default to
      * accumulating results
-     * @returns The function `levelIterative` returns an object of type `AbstractResultsByProperty<N>`.
+     * @returns The function `levelIterative` returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1133,7 +1202,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
      * specifies the property of the `BinaryTreeNode` object to collect at each level. It can be one of the following
      * values:
-     * @returns The function `listLevels` returns a 2D array of `AbstractResultByProperty<N>` objects.
+     * @returns The function `listLevels` returns a 2D array of `AbstractBinaryTreeNodeProperty<N>` objects.
      */
     AbstractBinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1217,7 +1286,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is used to specify the
      * property of the nodes that you want to retrieve in the results. It can be either the node itself or the name of the
      * property. If not provided, it defaults to `'id'`.
-     * @returns The function `morris` returns an object of type `AbstractResultsByProperty<N>`.
+     * @returns The function `morris` returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1331,12 +1400,11 @@ var AbstractBinaryTree = /** @class */ (function () {
         this._maxId = value;
     };
     AbstractBinaryTree.prototype._setIsDuplicatedVal = function (value) {
-        this._isDuplicatedVal = value;
+        this._isMergeDuplicatedVal = value;
     };
     AbstractBinaryTree.prototype._setRoot = function (v) {
         if (v) {
-            v.parent = null;
-            v.familyPosition = types_1.FamilyPosition.ROOT;
+            v.parent = undefined;
         }
         this._root = v;
     };
@@ -1433,7 +1501,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * to 'id'.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
      * can accept a value of type `NodeOrPropertyName`.
-     * @returns The method returns an object of type `AbstractResultsByProperty<T>`.
+     * @returns The method returns an object of type `AbstractBinaryTreeNodeProperties<T>`.
      */
     AbstractBinaryTree.prototype._getResultByPropertyName = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';