data-structure-typed 1.17.4 → 1.18.5

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

@@ -42,7 +42,7 @@ var FamilyPosition;
     FamilyPosition[FamilyPosition["root"] = 0] = "root";
     FamilyPosition[FamilyPosition["left"] = 1] = "left";
     FamilyPosition[FamilyPosition["right"] = 2] = "right";
-})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));
 /**
  * Enum representing different loop types.
  *
@@ -53,7 +53,7 @@ var LoopType;
 (function (LoopType) {
     LoopType[LoopType["iterative"] = 1] = "iterative";
     LoopType[LoopType["recursive"] = 2] = "recursive";
-})(LoopType = exports.LoopType || (exports.LoopType = {}));
+})(LoopType || (exports.LoopType = LoopType = {}));
 var BinaryTreeNode = /** @class */ (function () {
     function BinaryTreeNode(id, val, count) {
         this._familyPosition = FamilyPosition.root;
@@ -151,72 +151,29 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getId = function () {
-        return this._id;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getVal = function () {
-        return this._val;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getLeft = function () {
-        return this._left;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getRight = function () {
-        return this._right;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getParent = function () {
-        return this._parent;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getFamilyPosition = function () {
-        return this._familyPosition;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getCount = function () {
-        return this._count;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTreeNode.prototype.getHeight = function () {
-        return this._height;
+    BinaryTreeNode.prototype._createNode = function (id, val, count) {
+        return val !== null ? new BinaryTreeNode(id, val, count) : null;
     };
     BinaryTreeNode.prototype.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = new BinaryTreeNode(swapNode.id, val);
-        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;
+        var tempNode = this._createNode(swapNode.id, val);
+        if (tempNode instanceof BinaryTreeNode) {
+            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;
     };
     BinaryTreeNode.prototype.clone = function () {
-        return new BinaryTreeNode(this.id, this.val, this.count);
+        return this._createNode(this.id, this.val, this.count);
     };
     return BinaryTreeNode;
 }());
@@ -247,17 +204,73 @@ var BinaryTree = /** @class */ (function () {
             this._loopType = loopType;
         }
     }
+    Object.defineProperty(BinaryTree.prototype, "loopType", {
+        get: function () {
+            return this._loopType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "visitedId", {
+        get: function () {
+            return this._visitedId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "visitedVal", {
+        get: function () {
+            return this._visitedVal;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "visitedNode", {
+        get: function () {
+            return this._visitedNode;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "visitedCount", {
+        get: function () {
+            return this._visitedCount;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "visitedLeftSum", {
+        get: function () {
+            return this._visitedLeftSum;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "autoIncrementId", {
+        get: function () {
+            return this._autoIncrementId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "maxId", {
+        get: function () {
+            return this._maxId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "isDuplicatedVal", {
+        get: function () {
+            return this._isDuplicatedVal;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(BinaryTree.prototype, "root", {
         get: function () {
             return this._root;
         },
-        set: function (v) {
-            if (v) {
-                v.parent = null;
-                v.familyPosition = FamilyPosition.root;
-            }
-            this._root = v;
-        },
         enumerable: false,
         configurable: true
     });
@@ -265,9 +278,6 @@ var BinaryTree = /** @class */ (function () {
         get: function () {
             return this._size;
         },
-        set: function (v) {
-            this._size = v;
-        },
         enumerable: false,
         configurable: true
     });
@@ -275,54 +285,32 @@ var BinaryTree = /** @class */ (function () {
         get: function () {
             return this._count;
         },
-        set: function (v) {
-            this._count = v;
-        },
         enumerable: false,
         configurable: true
     });
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Getters (using the same name as the property) while utilizing separate method names for Setters.
-     * @returns The method is returning either a BinaryTreeNode object of type T or null.
-     */
-    BinaryTree.prototype.getRoot = function () {
-        return this._root;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTree.prototype.getSize = function () {
-        return this._size;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    BinaryTree.prototype.getCount = function () {
-        return this._count;
-    };
-    /**
-     * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
-     * null.
+     * The function creates a new binary tree node with the given id, value, and count if the value is not null, otherwise
+     * it returns null.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
-     * `BinaryTreeNodeId`, which could be a string or a number, depending on how you want to identify your nodes.
-     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary tree node. It can be of
-     * any type `T` or `null`.
-     * @param {number} [count] - The count parameter is an optional parameter that represents the number of occurrences of
-     * the value in the binary tree node. It is of type number.
-     * @returns The function `createNode` returns a `BinaryTreeNode<T>` object if the `val` parameter is not null.
-     * Otherwise, it returns null.
+     * `BinaryTreeNodeId`.
+     * @param {N | null} val - The `val` parameter represents the value of the node. It can be of type `N` (generic type)
+     * or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
+     * of occurrences of the value in the binary tree node. If not provided, the default value is `undefined`.
+     * @returns a BinaryTreeNode object if the value is not null, otherwise it returns null.
      */
-    BinaryTree.prototype.createNode = function (id, val, count) {
-        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    BinaryTree.prototype._createNode = function (id, val, count) {
+        var node = new BinaryTreeNode(id, val, count);
+        return node;
     };
     /**
      * The clear function resets the state of an object by setting its properties to their initial values.
      */
     BinaryTree.prototype.clear = function () {
-        this.root = null;
-        this.size = 0;
-        this.count = 0;
-        this._maxId = -1;
+        this._setRoot(null);
+        this._setSize(0);
+        this._setCount(0);
+        this._setMaxId(-1);
     };
     /**
      * The function checks if the size of an object is equal to zero and returns a boolean value.
@@ -336,10 +324,10 @@ var BinaryTree = /** @class */ (function () {
      * 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 {T} val - The value to be inserted into 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 `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @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.
      */
     BinaryTree.prototype.add = function (id, val, count) {
@@ -364,14 +352,14 @@ var BinaryTree = /** @class */ (function () {
             return;
         };
         var inserted;
-        var needInsert = val !== null ? new BinaryTreeNode(id, val, 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) {
                 existNode.count += count;
                 existNode.val = val;
                 if (needInsert !== null) {
-                    this.count += count;
+                    this._setCount(this.count + count);
                     inserted = existNode;
                 }
             }
@@ -380,10 +368,10 @@ var BinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this.root = val !== null ? new BinaryTreeNode(id, val, count) : null;
+            this._setRoot(val !== null ? this._createNode(id, val, count) : null);
             if (needInsert !== null) {
-                this.size = 1;
-                this.count = count;
+                this._setSize(1);
+                this._setCount(count);
             }
             inserted = this.root;
         }
@@ -391,7 +379,7 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * @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.
@@ -407,8 +395,8 @@ var BinaryTree = /** @class */ (function () {
                 }
                 parent.left = newNode;
                 if (newNode !== null) {
-                    this.size++;
-                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
+                    this._setSize(this.size + 1);
+                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 0);
                 }
                 return parent.left;
             }
@@ -419,8 +407,8 @@ var BinaryTree = /** @class */ (function () {
                 }
                 parent.right = newNode;
                 if (newNode !== null) {
-                    this.size++;
-                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
+                    this._setSize(this.size + 1);
+                    this._setCount((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
                 }
                 return parent.right;
             }
@@ -435,9 +423,9 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
-     * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
-     * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `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.
      */
     BinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
@@ -507,8 +495,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
      * was successful.
-     * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
-     * array of `BinaryTreeNode<T>` objects.
+     * @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.
      */
     BinaryTree.prototype.fill = function (data) {
@@ -533,27 +521,27 @@ var BinaryTree = /** @class */ (function () {
             node = undefined;
         else if (node.count > 1 && !ignoreCount) {
             node.count--;
-            this.count--;
+            this._setCount(this.count - 1);
         }
         else if (node instanceof BinaryTreeNode) {
             var _a = __read(this.getSubTreeSizeAndCount(node), 2), subSize = _a[0], subCount = _a[1];
             switch (node.familyPosition) {
                 case 0:
-                    this.size -= subSize;
-                    this.count -= subCount;
+                    this._setSize(this.size - subSize);
+                    this._setCount(this.count - subCount);
                     node = undefined;
                     break;
                 case 1:
                     if (node.parent) {
-                        this.size -= subSize;
-                        this.count -= subCount;
+                        this._setSize(this.size - subSize);
+                        this._setCount(this.count - subCount);
                         node.parent.left = null;
                     }
                     break;
                 case 2:
                     if (node.parent) {
-                        this.size -= subSize;
-                        this.count -= subCount;
+                        this._setSize(this.size - subSize);
+                        this._setCount(this.count - subCount);
                         node.parent.right = null;
                     }
                     break;
@@ -563,7 +551,7 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function calculates the depth of a binary tree node by traversing its parent nodes.
-     * @param node - BinaryTreeNode<T> - This is the node for which we want to calculate the depth. It is a generic type,
+     * @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.
      */
@@ -578,8 +566,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the height of the binary tree.
+     * @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
      * @returns the height of the binary tree.
      */
@@ -629,8 +617,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the minimum height of the binary
+     * @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.
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
@@ -681,8 +669,8 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function checks if a binary tree is balanced by comparing the minimum height and the maximum height of the tree.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
-     * of type `BinaryTreeNode<T> | null`, which means it can either be a `BinaryTreeNode` object or `null`.
+     * @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`.
      * @returns The method is returning a boolean value.
      */
     BinaryTree.prototype.isBalanced = function (beginRoot) {
@@ -691,14 +679,14 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function `getNodes` returns an array of binary tree nodes that match a given property value, with options for
      * searching recursively or iteratively.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @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 `BinaryTreeNode<T> | null | undefined` objects.
+     * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
      */
     BinaryTree.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -734,8 +722,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * 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 | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of a binary tree node that you want to check.
+     * @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.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the name of the property to check for in the nodes.
      * @returns a boolean value.
@@ -746,8 +734,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * 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 | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @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 of the binary tree node to search for. If not provided, it defaults to `'id'`.
      * @returns a BinaryTreeNode object or null.
@@ -761,7 +749,7 @@ var BinaryTree = /** @class */ (function () {
      * 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 `BinaryTreeNode<T>` objects, representing the path from
+     * @returns The function `getPathToRoot` returns an array of `N` objects, representing the path from
      * the given `node` to the root of the binary tree.
      */
     BinaryTree.prototype.getPathToRoot = function (node) {
@@ -776,7 +764,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getLeftMost` function returns the leftmost node in a binary tree, either recursively or iteratively using tail
      * recursion optimization.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @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.
@@ -806,7 +794,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or iteratively using
      * tail recursion optimization.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @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.
@@ -833,10 +821,9 @@ var BinaryTree = /** @class */ (function () {
             return _traverse_5(node);
         }
     };
-    // --- start additional methods ---
     /**
      * The `isBST` function checks if a binary tree is a binary search tree.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @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
@@ -876,7 +863,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
      * traversal.
-     * @param {BinaryTreeNode<T> | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
+     * @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.
@@ -907,6 +894,7 @@ var BinaryTree = /** @class */ (function () {
             return res;
         }
     };
+    // --- start additional methods ---
     /**
      * The function `subTreeSum` calculates the sum of a specified property in a binary tree, either recursively or
      * iteratively.
@@ -980,7 +968,7 @@ var BinaryTree = /** @class */ (function () {
                     break;
                 case 'count':
                     cur.count += delta;
-                    _this.count += delta;
+                    _this._setCount(_this.count + delta);
                     break;
                 default:
                     cur.id += delta;
@@ -1013,7 +1001,7 @@ var BinaryTree = /** @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 `ResultsByProperty<T>`.
+     * @returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1041,7 +1029,7 @@ var BinaryTree = /** @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 `ResultsByProperty<T>`.
+     * @returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1128,14 +1116,14 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `levelIterative` function performs a level-order traversal on a binary tree and returns the values of the nodes
      * in an array, based on a specified property name.
-     * @param {BinaryTreeNode<T> | null} node - The `node` parameter is a BinaryTreeNode object representing the starting
+     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object representing the starting
      * node for the level order traversal. It can be null if no specific node is provided, in which case the root node of
      * the tree is used as the starting node.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
      * 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 `ResultsByProperty<T>`.
+     * @returns The function `levelIterative` returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1160,12 +1148,12 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The `listLevels` function collects nodes from a binary tree by a specified property and organizes them into levels.
-     * @param {BinaryTreeNode<T> | null} node - The `node` parameter is a BinaryTreeNode object or null. It represents the
+     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object or null. It represents the
      * root node of a binary tree. If it is null, the function will use the root node of the current binary tree instance.
      * @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 `ResultByProperty<T>` objects.
+     * @returns The function `listLevels` returns a 2D array of `ResultByProperty<N>` objects.
      */
     BinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1249,7 +1237,7 @@ var BinaryTree = /** @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 `ResultsByProperty<T>`.
+     * @returns The function `morris` returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1338,6 +1326,46 @@ var BinaryTree = /** @class */ (function () {
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
     };
+    BinaryTree.prototype._setLoopType = function (value) {
+        this._loopType = value;
+    };
+    BinaryTree.prototype._setVisitedId = function (value) {
+        this._visitedId = value;
+    };
+    BinaryTree.prototype._setVisitedVal = function (value) {
+        this._visitedVal = value;
+    };
+    BinaryTree.prototype._setVisitedNode = function (value) {
+        this._visitedNode = value;
+    };
+    BinaryTree.prototype.setVisitedCount = function (value) {
+        this._visitedCount = value;
+    };
+    BinaryTree.prototype._setVisitedLeftSum = function (value) {
+        this._visitedLeftSum = value;
+    };
+    BinaryTree.prototype._setAutoIncrementId = function (value) {
+        this._autoIncrementId = value;
+    };
+    BinaryTree.prototype._setMaxId = function (value) {
+        this._maxId = value;
+    };
+    BinaryTree.prototype._setIsDuplicatedVal = function (value) {
+        this._isDuplicatedVal = value;
+    };
+    BinaryTree.prototype._setRoot = function (v) {
+        if (v) {
+            v.parent = null;
+            v.familyPosition = FamilyPosition.root;
+        }
+        this._root = v;
+    };
+    BinaryTree.prototype._setSize = function (v) {
+        this._size = v;
+    };
+    BinaryTree.prototype._setCount = function (v) {
+        this._count = v;
+    };
     /**
      * The function resets the values of several arrays used for tracking visited nodes and their properties.
      */
@@ -1352,9 +1380,9 @@ var BinaryTree = /** @class */ (function () {
      * 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 {(BinaryTreeNode<T> | null | undefined)[]} result - An array that stores the matching nodes found during the
+     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes found during the
      * traversal.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
+     * @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 {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
@@ -1395,7 +1423,7 @@ var BinaryTree = /** @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 `BinaryTreeNode<T>`, which represents a node in a binary tree.
+     * @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