data-structure-typed 1.18.7 → 1.19.0

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

@@ -39,21 +39,16 @@ 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.
+     * The constructor function initializes a BinaryTreeNode object with an id and an optional value.
      * @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.
+     * of the binary tree node. It is used to distinguish one node from another in the binary tree.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value that will be
+     * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
-    function AbstractBinaryTreeNode(id, val, count) {
-        this._familyPosition = types_1.FamilyPosition.ROOT;
-        this._count = 1;
+    function AbstractBinaryTreeNode(id, val) {
         this._height = 0;
         this._id = id;
         this._val = val;
-        this._count = count !== null && count !== void 0 ? count : 1;
     }
     Object.defineProperty(AbstractBinaryTreeNode.prototype, "id", {
         get: function () {
@@ -82,7 +77,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.LEFT;
             }
             this._left = v;
         },
@@ -96,7 +90,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.RIGHT;
             }
             this._right = v;
         },
@@ -113,67 +106,56 @@ 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", {
+    Object.defineProperty(AbstractBinaryTreeNode.prototype, "height", {
         get: function () {
-            return this._count;
+            return this._height;
         },
         set: function (v) {
-            this._count = v;
+            this._height = v;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "height", {
+    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
+        /**
+         * The function determines the position of a node in a family tree structure.
+         * @returns a value of type `FamilyPosition`.
+         */
         get: function () {
-            return this._height;
-        },
-        set: function (v) {
-            this._height = v;
+            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} swapNode - 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 (swapNode) {
-        var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = this.createNode(swapNode.id, val);
-        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;
-            this.id = tempNode.id;
-            this.val = tempNode.val;
-            this.count = tempNode.count;
-            this.height = tempNode.height;
-        }
-        return swapNode;
-    };
-    /**
-     * 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 AbstractBinaryTreeNode;
 }());
 exports.AbstractBinaryTreeNode = AbstractBinaryTreeNode;
@@ -184,116 +166,132 @@ var AbstractBinaryTree = /** @class */ (function () {
      * tree.
      */
     function AbstractBinaryTree(options) {
+        this._root = null;
+        this._size = 0;
         this._loopType = types_1.LoopType.ITERATIVE;
+        this._autoIncrementId = false;
+        this._maxId = -1;
+        // TODO this variable may be moved to TreeMultiset
+        this._isMergeDuplicatedVal = true;
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
         this._visitedCount = [];
         this._visitedLeftSum = [];
-        this._autoIncrementId = false;
-        this._maxId = -1;
-        this._isDuplicatedVal = false;
-        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;
         }
     }
-    Object.defineProperty(AbstractBinaryTree.prototype, "loopType", {
-        get: function () {
-            return this._loopType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedId", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "root", {
         get: function () {
-            return this._visitedId;
+            return this._root;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedVal", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "size", {
         get: function () {
-            return this._visitedVal;
+            return this._size;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedNode", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "loopType", {
         get: function () {
-            return this._visitedNode;
+            return this._loopType;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedCount", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "autoIncrementId", {
         get: function () {
-            return this._visitedCount;
+            return this._autoIncrementId;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedLeftSum", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "maxId", {
         get: function () {
-            return this._visitedLeftSum;
+            return this._maxId;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "autoIncrementId", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "isMergeDuplicatedVal", {
         get: function () {
-            return this._autoIncrementId;
+            return this._isMergeDuplicatedVal;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "maxId", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "visitedId", {
         get: function () {
-            return this._maxId;
+            return this._visitedId;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "isDuplicatedVal", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "visitedVal", {
         get: function () {
-            return this._isDuplicatedVal;
+            return this._visitedVal;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "root", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "visitedNode", {
         get: function () {
-            return this._root;
+            return this._visitedNode;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "size", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "visitedCount", {
         get: function () {
-            return this._size;
+            return this._visitedCount;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "count", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "visitedLeftSum", {
         get: function () {
-            return this._count;
+            return this._visitedLeftSum;
         },
         enumerable: false,
         configurable: true
     });
     /**
-     * The clear function resets the state of an object by setting its properties to their initial values.
+     * The `swapLocation` function swaps the location of two nodes in a binary tree.
+     * @param {N} srcNode - The source node that you want to swap with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+     * be swapped to.
+     * @returns The `destNode` is being returned.
+     */
+    AbstractBinaryTree.prototype.swapLocation = function (srcNode, destNode) {
+        var val = destNode.val, height = destNode.height, id = destNode.id;
+        var tempNode = this.createNode(id, val);
+        if (tempNode) {
+            tempNode.height = height;
+            if (tempNode instanceof AbstractBinaryTreeNode) {
+                // TODO should we consider the left, right children?
+                destNode.id = srcNode.id;
+                destNode.val = srcNode.val;
+                destNode.height = srcNode.height;
+                srcNode.id = tempNode.id;
+                srcNode.val = tempNode.val;
+                srcNode.height = tempNode.height;
+            }
+        }
+        return destNode;
+    };
+    /**
+     * The clear() function resets the root, size, and maxId properties to their initial values.
      */
     AbstractBinaryTree.prototype.clear = function () {
         this._setRoot(null);
         this._setSize(0);
-        this._setCount(0);
         this._setMaxId(-1);
     };
     /**
@@ -304,19 +302,16 @@ var AbstractBinaryTree = /** @class */ (function () {
         return this.size === 0;
     };
     /**
-     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
-     * already exists.
-     * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
-     * identify each node in the binary tree.
-     * @param {N} val - The value to be inserted into the binary tree.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
-     * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `add` returns a `N` object if a new node is inserted, or `null` if no new node
-     * is inserted, or `undefined` if the insertion fails.
+     * The `add` function adds a new node to a binary tree, updating the value of an existing node if it already exists.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
+     * provided, the default value will be the same as the `id` parameter.
+     * @param {number} [count] - The `count` parameter is an optional number that represents the number of times the value
+     * should be added to the binary tree. If not provided, the default value is `undefined`.
+     * @returns The function `add` returns either a `BinaryTreeNode` object (`N`), `null`, or `undefined`.
      */
     AbstractBinaryTree.prototype.add = function (id, val, count) {
         var _this = this;
-        count = count !== null && count !== void 0 ? count : 1;
         var _bfs = function (root, newNode) {
             var queue = [root];
             while (queue.length > 0) {
@@ -336,14 +331,12 @@ 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) : null;
         var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
-                existNode.count += count;
                 existNode.val = val !== null && val !== void 0 ? val : id;
                 if (needInsert !== null) {
-                    this._setCount(this.count + count);
                     inserted = existNode;
                 }
             }
@@ -352,48 +345,42 @@ 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) : null);
             if (needInsert !== null) {
                 this._setSize(1);
-                this._setCount(count);
             }
             inserted = this.root;
         }
         return inserted;
     };
     /**
-     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * The function adds a new node to the left or right child of a parent node, updating the size of the tree if
+     * necessary.
      * @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.
+     * @returns either the left child node, the right child node, or undefined.
      */
     AbstractBinaryTree.prototype.addTo = function (newNode, parent) {
-        var _a, _b;
         if (parent) {
             if (parent.left === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.LEFT;
                 }
                 parent.left = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 0);
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                 }
                 parent.right = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
                 }
                 return parent.right;
             }
@@ -406,22 +393,23 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of `N` objects or an array of
+     * `N['val']` values.
+     * @returns The function `addMany` returns an array of values of type `N | null | undefined`.
      */
     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 }; }
@@ -434,53 +422,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));
+                    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 }; }
@@ -493,87 +477,95 @@ var AbstractBinaryTree = /** @class */ (function () {
         return inserted;
     };
     /**
-     * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
-     * was successful.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
-     * @returns The method is returning a boolean value.
+     * The `fill` function clears the current data and adds new data, returning a boolean indicating if the operation was
+     * successful.
+     * @param {N[] | Array<N['val']>} data - The `data` parameter can be either an array of objects or an array of arrays.
+     * Each object or array should have a property called `val`.
+     * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.fill = function (data) {
         this.clear();
         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} nodeOrId - The `nodeOrId` parameter can be either a node object (`N`) or a binary tree
+     * node ID (`BinaryTreeNodeId`).
      * @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.
+     * whether to ignore the count of the nodes in the binary tree. If `ignoreCount` is set to `true`, the count of the
+     * nodes in the binary tree will not be updated after removing a node. If `ignoreCount`
+     * @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--;
-            this._setCount(this.count - 1);
+    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.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;
+                }
+                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                    parent.right = curr.right;
+                }
+                needBalanced = parent;
+            }
         }
-        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;
-                    }
-                    break;
-                case 2:
-                    if (node.parent) {
-                        this._setSize(this.size - subSize);
-                        this._setCount(this.count - subCount);
-                        node.parent.right = null;
-                    }
-                    break;
+        else {
+            var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+            if (leftSubTreeRightMost) {
+                var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
+                if (parentOfLeftSubTreeMax) {
+                    if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                        parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                    else
+                        parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                    needBalanced = parentOfLeftSubTreeMax;
+                }
             }
         }
-        return [{ deleted: node, needBalanced: null }];
+        this._setSize(this.size - 1);
+        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;
     };
     /**
-     * The `getHeight` function calculates the maximum height of a binary tree using either a recursive or iterative
-     * approach.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `N | null`. It represents the starting node from which to calculate the height of the binary tree.
-     * If no value is provided for `beginRoot`, the function will use the `root` property of the class instance as
+     * The `getHeight` function calculates the maximum height of a binary tree, either recursively or iteratively.
+     * @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 height of the binary tree.
      */
     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) {
@@ -587,39 +579,30 @@ var AbstractBinaryTree = /** @class */ (function () {
             return _getMaxHeight_1(beginRoot);
         }
         else {
-            var stack = [];
-            var node = beginRoot, last = null;
-            var depths = new Map();
-            while (stack.length > 0 || node) {
-                if (node) {
-                    stack.push(node);
-                    node = node.left;
+            if (!beginRoot) {
+                return -1;
+            }
+            var stack = [{ node: beginRoot, depth: 0 }];
+            var maxHeight = 0;
+            while (stack.length > 0) {
+                var _a = stack.pop(), node = _a.node, depth = _a.depth;
+                if (node.left) {
+                    stack.push({ node: node.left, depth: depth + 1 });
                 }
-                else {
-                    node = stack[stack.length - 1];
-                    if (!node.right || last === node.right) {
-                        node = stack.pop();
-                        if (node) {
-                            var leftHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            var rightHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
-                            depths.set(node, 1 + Math.max(leftHeight, rightHeight));
-                            last = node;
-                            node = null;
-                        }
-                    }
-                    else
-                        node = node.right;
+                if (node.right) {
+                    stack.push({ node: node.right, depth: depth + 1 });
                 }
+                maxHeight = Math.max(maxHeight, depth);
             }
-            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+            return maxHeight;
         }
     };
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `N | null`. It represents the starting node from which to calculate the minimum height of the binary
-     * tree. If no value is provided for `beginRoot`, the function will use the root node of the binary tree.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It
+     * represents the starting node from which to calculate the minimum height of a binary tree. If no value is provided
+     * for `beginRoot`, the `this.root` property is used as the default value.
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
     AbstractBinaryTree.prototype.getMinHeight = function (beginRoot) {
@@ -668,25 +651,25 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The function checks if a binary tree is balanced by comparing the minimum height and the maximum height of the tree.
-     * @param {N | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
-     * of type `N | null`, which means it can either be a `BinaryTreeNode` object or `null`.
+     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the height of the
+     * tree.
+     * @param {N | null} [beginRoot] - The parameter `beginRoot` is of type `N` or `null`. It represents the root node of a
+     * tree or null if the tree is empty.
      * @returns The method is returning a boolean value.
      */
-    AbstractBinaryTree.prototype.isBalanced = function (beginRoot) {
+    AbstractBinaryTree.prototype.isPerfectlyBalanced = function (beginRoot) {
         return (this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot));
     };
     /**
-     * The function `getNodes` returns an array of binary tree nodes that match a given property value, with options for
-     * searching recursively or iteratively.
+     * The function `getNodes` returns an array of nodes that match a given property name and value in a binary tree.
      * @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 when searching for nodes. 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 `nodeProperty` or `propertyName` criteria. If `onlyOne` is set to `true`, the
-     * function will stop traversing the tree and return the first matching node. If `
-     * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
+     * return only one node that matches the given `nodeProperty` or `propertyName`. If `onlyOne` is set to `true`, the
+     * function will stop traversing the tree and return the first matching node. If `only
+     * @returns an array of nodes (type N).
      */
     AbstractBinaryTree.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -694,7 +677,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             return [];
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         var result = [];
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_1 = function (cur) {
                 if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
@@ -720,25 +703,27 @@ var AbstractBinaryTree = /** @class */ (function () {
         return result;
     };
     /**
-     * The function checks if a binary tree node has a specific property or if any node in the tree has a specific
-     * property.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `N`. It represents the property of a binary tree node that you want to check.
+     * The function checks if a binary tree node has a specific property.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or `N`.
+     * It represents the property of the binary tree node that you want to check.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the name of the property to check for in the nodes.
+     * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'id'.
      * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.has = function (nodeProperty, propertyName) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return this.getNodes(nodeProperty, propertyName).length > 0;
     };
     /**
-     * The function returns the first binary tree node that matches the given property name and value, or null if no match
-     * is found.
-     * @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.
+     * The function returns the first node that matches the given property name and value, or null if no matching node is
+     * found.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or `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 of the binary tree node to search for. If not provided, it defaults to `'id'`.
-     * @returns a BinaryTreeNode object or null.
+     * specifies the property name to be used for searching the binary tree nodes. If this parameter is not provided, the
+     * default value is set to `'id'`.
+     * @returns either the value of the specified property of the node, or the node itself if no property name is provided.
+     * If no matching node is found, it returns null.
      */
     AbstractBinaryTree.prototype.get = function (nodeProperty, propertyName) {
         var _a;
@@ -746,11 +731,10 @@ var AbstractBinaryTree = /** @class */ (function () {
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
     };
     /**
-     * The function getPathToRoot returns an array of BinaryTreeNode objects representing the path from a given node to the
-     * root of a binary tree.
-     * @param node - The `node` parameter is a BinaryTreeNode object.
-     * @returns The function `getPathToRoot` returns an array of `N` objects, representing the path from
-     * the given `node` to the root of the binary tree.
+     * The function getPathToRoot takes a node and returns an array of nodes representing the path from the given node to
+     * the root node.
+     * @param {N} node - The parameter `node` represents a node in a tree data structure.
+     * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
     AbstractBinaryTree.prototype.getPathToRoot = function (node) {
         var result = [];
@@ -762,24 +746,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
@@ -788,16 +776,18 @@ var AbstractBinaryTree = /** @class */ (function () {
                     return cur;
                 return _traverse_3.cont(cur.left);
             });
-            return _traverse_3(node);
+            return _traverse_3(beginRoot);
         }
     };
     /**
      * The `getRightMost` function returns the rightmost 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 rightmost node in a binary tree. If no node is
-     * provided, the function will use the root node of the binary tree.
-     * @returns The `getRightMost` function returns the rightmost node in a binary tree.
+     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
+     * starting node from which we want to find the rightmost node. If no node is provided, the `node` parameter defaults
+     * to `this.root`, which is the root node of the data structure
+     * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If the `node` parameter is
+     * not provided, it defaults to the root node of the tree. If the tree is empty or the `node` parameter is `null`, the
+     * function returns `null`.
      */
     AbstractBinaryTree.prototype.getRightMost = function (node) {
         node = node !== null && node !== void 0 ? node : this.root;
@@ -822,11 +812,12 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * The function checks if a binary search tree is valid by traversing it either recursively or iteratively.
      * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.isBSTByRooted = function (node) {
+        // TODO there is a bug
         if (!node)
             return true;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -866,52 +857,48 @@ var AbstractBinaryTree = /** @class */ (function () {
         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.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
-     * tree.
-     * @returns The function `getSubTreeSizeAndCount` returns an array `[number, number]`. The first element of the array
-     * represents the size of the subtree, and the second element represents the count of the nodes in the subtree.
+     * The function calculates the size of a subtree by traversing it either recursively or iteratively.
+     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
+     * binary tree.
+     * @returns the size of the subtree rooted at `subTreeRoot`.
      */
-    AbstractBinaryTree.prototype.getSubTreeSizeAndCount = function (subTreeRoot) {
-        var res = [0, 0];
+    AbstractBinaryTree.prototype.getSubTreeSize = function (subTreeRoot) {
+        var size = 0;
         if (!subTreeRoot)
-            return res;
+            return size;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_6 = function (cur) {
-                res[0]++;
-                res[1] += cur.count;
+                size++;
                 cur.left && _traverse_6(cur.left);
                 cur.right && _traverse_6(cur.right);
             };
             _traverse_6(subTreeRoot);
-            return res;
+            return size;
         }
         else {
             var stack = [subTreeRoot];
             while (stack.length > 0) {
                 var cur = stack.pop();
-                res[0]++;
-                res[1] += cur.count;
+                size++;
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
-            return res;
+            return size;
         }
     };
-    // --- start additional methods ---
     /**
-     * The function `subTreeSum` calculates the sum of a specified property in a binary tree, either recursively or
-     * iteratively.
-     * @param subTreeRoot - The subTreeRoot parameter is the root node of the subtree for which you want to calculate the
-     * sum.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` object to use for calculating the sum. If `propertyName` is not
-     * provided, it defaults to `'val'`.
-     * @returns a number, which is the sum of the values of the nodes in the subtree rooted at `subTreeRoot`.
+     * The function `subTreeSum` calculates the sum of a specified property in a binary tree or 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.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
+     * property of the binary tree node to use for calculating the sum. It can be either 'id' or 'val'. If propertyName is
+     * not provided, it defaults to 'id'.
+     * @returns a number, which is the sum of the values of the specified property in the subtree rooted at `subTreeRoot`.
      */
     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;
@@ -921,9 +908,6 @@ var AbstractBinaryTree = /** @class */ (function () {
                 case 'id':
                     needSum = cur.id;
                     break;
-                case 'count':
-                    needSum = cur.count;
-                    break;
                 case 'val':
                     needSum = typeof cur.val === 'number' ? cur.val : 0;
                     break;
@@ -953,17 +937,19 @@ 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 node in the binary tree. It can also be `null` if there is no subtree to add to.
      * @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.
      * @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. If not provided, 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) {
@@ -971,10 +957,6 @@ var AbstractBinaryTree = /** @class */ (function () {
                 case 'id':
                     cur.id += delta;
                     break;
-                case 'count':
-                    cur.count += delta;
-                    _this._setCount(_this.count + delta);
-                    break;
                 default:
                     cur.id += delta;
                     break;
@@ -1000,13 +982,13 @@ var AbstractBinaryTree = /** @class */ (function () {
         return true;
     };
     /**
-     * The BFS function performs a breadth-first search on a binary tree and returns the results based on a specified node
-     * or property name.
+     * The BFS function performs a breadth-first search on a binary tree, accumulating properties of each node based on a
+     * specified property name.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
-     * 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 `AbstractBinaryTreeNodeProperties<N>`.
+     * represents either a node or a property name. If a node is provided, the breadth-first search (BFS) algorithm will be
+     * performed starting from that node. If a property name is provided, the BFS algorithm will be performed starting from
+     * the
+     * @returns an instance of the `AbstractBinaryTreeNodeProperties` class with generic type `N`.
      */
     AbstractBinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1025,16 +1007,15 @@ var AbstractBinaryTree = /** @class */ (function () {
         return this._getResultByPropertyName(nodeOrPropertyName);
     };
     /**
-     * The DFS function performs a depth-first search traversal on a binary tree and returns the results based on the
-     * specified pattern and node or property name.
-     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is used to specify the order in which the nodes
-     * of a binary tree are traversed during the Depth-First Search (DFS) algorithm. It can take one of three values: 'in',
-     * 'pre', or 'post'.
+     * The DFS function performs a depth-first search traversal on a binary tree and returns the accumulated properties of
+     * each node based on the specified pattern and property name.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is used to specify the traversal order of the
+     * binary tree. It can have three possible values:
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is a string that represents
-     * 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 `AbstractBinaryTreeNodeProperties<N>`.
+     * the name of a property of the nodes in the binary tree. This property will be used to accumulate values during the
+     * depth-first search traversal. If no `nodeOrPropertyName` is provided, the default value is `'id'`.
+     * @returns an instance of the AbstractBinaryTreeNodeProperties class, which contains the accumulated properties of the
+     * binary tree nodes based on the specified pattern and node or property name.
      */
     AbstractBinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1070,11 +1051,15 @@ var AbstractBinaryTree = /** @class */ (function () {
         return this._getResultByPropertyName(nodeOrPropertyName);
     };
     /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative DFS equals to recursive DFS which is O(n) because of the stack
-     * @param pattern
-     * @param nodeOrPropertyName
-     * @constructor
+     * The DFSIterative function performs an iterative depth-first search traversal on a binary tree, with the option to
+     * specify the traversal pattern and the property name to accumulate results by.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter determines the order in which the nodes of the
+     * binary tree are visited during the depth-first search. It can have one of the following values:
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is used to specify the
+     * property of the nodes that you want to retrieve or perform operations on during the depth-first search traversal. By
+     * default, it is set to `'id'`, which means that the traversal will accumulate results based on the `id` property of
+     * the
+     * @returns an object of type AbstractBinaryTreeNodeProperties<N>.
      */
     AbstractBinaryTree.prototype.DFSIterative = function (pattern, nodeOrPropertyName) {
         pattern = pattern || 'in';
@@ -1177,15 +1162,12 @@ var AbstractBinaryTree = /** @class */ (function () {
                 case 'node':
                     levelsNodes[level].push(node);
                     break;
-                case 'count':
-                    levelsNodes[level].push(node.count);
-                    break;
                 default:
                     levelsNodes[level].push(node.id);
                     break;
             }
         };
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _recursive_1 = function (node, level) {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
@@ -1234,15 +1216,13 @@ var AbstractBinaryTree = /** @class */ (function () {
     };
     /**
      * The `morris` function performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris
-     * traversal algorithm and returns the results based on the specified property name.
-     * The time complexity of Morris traversal is O(n), it's may slower than others
-     * The space complexity  Morris traversal is O(1) because no using stack
-     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that determines the
-     * traversal pattern of the binary tree. It can have one of three values:
+     * traversal algorithm.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter determines the traversal pattern for the binary
+     * tree. It can have one of three values:
      * @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 `AbstractBinaryTreeNodeProperties<N>`.
+     * property name of the nodes that you want to retrieve. It can be any valid property name of the nodes in the binary
+     * tree.
+     * @returns an array of AbstractBinaryTreeNodeProperties<N> objects.
      */
     AbstractBinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1331,71 +1311,114 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
     };
+    /**
+     * The function sets the loop type for a protected variable.
+     * @param {LoopType} value - The value parameter is of type LoopType.
+     */
     AbstractBinaryTree.prototype._setLoopType = function (value) {
         this._loopType = value;
     };
+    /**
+     * The function sets the value of the `_visitedId` property in a protected manner.
+     * @param {BinaryTreeNodeId[]} value - value is an array of BinaryTreeNodeId values.
+     */
     AbstractBinaryTree.prototype._setVisitedId = function (value) {
         this._visitedId = value;
     };
+    /**
+     * The function sets the value of the "_visitedVal" property to the given array.
+     * @param value - An array of type N.
+     */
     AbstractBinaryTree.prototype._setVisitedVal = function (value) {
         this._visitedVal = value;
     };
+    /**
+     * The function sets the value of the _visitedNode property.
+     * @param {N[]} value - N[] is an array of elements of type N.
+     */
     AbstractBinaryTree.prototype._setVisitedNode = function (value) {
         this._visitedNode = value;
     };
+    /**
+     * The function sets the value of the visitedCount property.
+     * @param {number[]} value - The value parameter is an array of numbers.
+     */
     AbstractBinaryTree.prototype.setVisitedCount = function (value) {
         this._visitedCount = value;
     };
+    /**
+     * The function sets the value of the `_visitedLeftSum` property to the provided array.
+     * @param {number[]} value - An array of numbers that represents the visited left sum.
+     */
     AbstractBinaryTree.prototype._setVisitedLeftSum = function (value) {
         this._visitedLeftSum = value;
     };
+    /**
+     * The function sets the value of the _autoIncrementId property.
+     * @param {boolean} value - The value parameter is a boolean that determines whether the id should be automatically
+     * incremented or not. If value is true, the id will be automatically incremented. If value is false, the id will not
+     * be automatically incremented.
+     */
     AbstractBinaryTree.prototype._setAutoIncrementId = function (value) {
         this._autoIncrementId = value;
     };
+    /**
+     * The function sets the maximum ID value.
+     * @param {number} value - The value parameter is a number that represents the new maximum ID value.
+     */
     AbstractBinaryTree.prototype._setMaxId = function (value) {
         this._maxId = value;
     };
+    /**
+     * The function sets the value of a protected property called "_isMergeDuplicatedVal".
+     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedVal
+     * property should be set to true or false.
+     */
     AbstractBinaryTree.prototype._setIsDuplicatedVal = function (value) {
-        this._isDuplicatedVal = value;
+        this._isMergeDuplicatedVal = value;
     };
+    /**
+     * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
+     * parent property of the value to undefined.
+     * @param {N | null} v - The parameter `v` is of type `N | null`, which means it can either be of type `N` or `null`.
+     */
     AbstractBinaryTree.prototype._setRoot = function (v) {
         if (v) {
-            v.parent = null;
-            v.familyPosition = types_1.FamilyPosition.ROOT;
+            v.parent = undefined;
         }
         this._root = v;
     };
+    /**
+     * The function sets the size of a protected variable.
+     * @param {number} v - number
+     */
     AbstractBinaryTree.prototype._setSize = function (v) {
         this._size = v;
     };
-    AbstractBinaryTree.prototype._setCount = function (v) {
-        this._count = v;
-    };
     /**
-     * The function resets the values of several arrays used for tracking visited nodes and their properties.
+     * The function `_resetResults` resets the values of several arrays used for tracking visited nodes and their
+     * properties.
      */
     AbstractBinaryTree.prototype._resetResults = function () {
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
-        this._visitedCount = [];
         this._visitedLeftSum = [];
     };
     /**
      * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
      * a result array.
-     * @param cur - The current binary tree node that is being checked.
-     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes found during the
-     * traversal.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
-     * the binary tree nodes. It can be either the `id`, `count`, or `val` property of the node.
+     * @param {N} cur - The current node being processed.
+     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter is either a `BinaryTreeNodeId` or a `N`
+     * type. It represents the property value that we are comparing against in the switch statement.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` object that you want to compare with the `nodeProperty` value. It can
-     * be one of the following values: 'id', 'count', or 'val'. If no `propertyName` is provided,
+     * specifies the property name to compare against when pushing nodes into the `result` array. It can be either `'id'`
+     * or `'val'`. If it is not provided or is not equal to `'id'` or `'val'`, the
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * stop after finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set to
      * `true`, the function will stop after finding the first matching node and return `true`. If `onlyOne
-     * @returns a boolean value indicating whether or not a node was pushed into the result array.
+     * @returns a boolean value indicating whether only one matching node should be pushed into the result array.
      */
     AbstractBinaryTree.prototype._pushByPropertyNameStopOrNot = function (cur, result, nodeProperty, propertyName, onlyOne) {
         switch (propertyName) {
@@ -1405,12 +1428,6 @@ var AbstractBinaryTree = /** @class */ (function () {
                     return !!onlyOne;
                 }
                 break;
-            case 'count':
-                if (cur.count === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
             case 'val':
                 if (cur.val === nodeProperty) {
                     result.push(cur);
@@ -1426,12 +1443,11 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The function `_accumulatedByPropertyName` pushes a property value of a binary tree node into an array based on the
-     * provided property name or a default property name.
-     * @param node - The `node` parameter is of type `N`, which represents a node in a binary tree.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
-     * can be either a string representing a property name or a reference to a node object. If it is a string, it specifies
-     * the property name of the node that should be accumulated. If it is a node object, it specifies the node itself
+     * The function `_accumulatedByPropertyName` accumulates values from a given node based on the specified property name.
+     * @param {N} node - The `node` parameter is of type `N`, which represents a node in a data structure.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
+     * can be either a string representing a property name or a reference to a `Node` object. If it is a string, it
+     * specifies the property name to be used for accumulating values. If it is a `Node` object, it specifies
      */
     AbstractBinaryTree.prototype._accumulatedByPropertyName = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1445,20 +1461,21 @@ var AbstractBinaryTree = /** @class */ (function () {
             case 'node':
                 this._visitedNode.push(node);
                 break;
-            case 'count':
-                this._visitedCount.push(node.count);
-                break;
             default:
                 this._visitedId.push(node.id);
                 break;
         }
     };
     /**
-     * The function `_getResultByPropertyName` returns different results based on the provided property name or defaulting
-     * to 'id'.
+     * The time complexity of Morris traversal is O(n), it's may slower than others
+     * The space complexity  Morris traversal is O(1) because no using stack
+     */
+    /**
+     * The function `_getResultByPropertyName` returns the corresponding property value based on the given node or property
+     * name.
      * @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 `AbstractBinaryTreeNodeProperties<T>`.
+     * can accept either a `NodeOrPropertyName` type or be undefined.
+     * @returns The method `_getResultByPropertyName` returns an instance of `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype._getResultByPropertyName = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1469,8 +1486,6 @@ var AbstractBinaryTree = /** @class */ (function () {
                 return this._visitedVal;
             case 'node':
                 return this._visitedNode;
-            case 'count':
-                return this._visitedCount;
             default:
                 return this._visitedId;
         }