data-structure-typed 1.17.4 → 1.18.0

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

@@ -187,7 +187,7 @@ var AVLTree = /** @class */ (function (_super) {
             B.parent = parentOfA;
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if ((parentOfA === null || parentOfA === void 0 ? void 0 : parentOfA.left) === A) {
@@ -232,7 +232,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {
@@ -271,7 +271,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (B)
-                this.root = B;
+                this._setRoot(B);
         }
         else {
             if (parentOfA) {
@@ -315,7 +315,7 @@ var AVLTree = /** @class */ (function (_super) {
         }
         if (A === this.root) {
             if (C)
-                this.root = C;
+                this._setRoot(C);
         }
         else {
             if (parentOfA) {

package/dist/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -6,7 +6,6 @@
  * @license MIT License
  */
 export declare class BinaryIndexedTree {
-    private readonly _sumTree;
     /**
      * The constructor initializes an array with a specified length and fills it with zeros.
      * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
@@ -14,6 +13,8 @@ export declare class BinaryIndexedTree {
      * The size of the sum tree array is `n + 1` because
      */
     constructor(n: number);
+    private _sumTree;
+    get sumTree(): number[];
     static lowBit(x: number): number;
     /**
      * The update function updates the values in a binary indexed tree by adding a delta value to the specified index and
@@ -41,4 +42,5 @@ export declare class BinaryIndexedTree {
      * @returns the sum of the elements in the range specified by the start and end indices.
      */
     getRangeSum(start: number, end: number): number;
+    protected _setSumTree(value: number[]): void;
 }

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

@@ -18,6 +18,13 @@ var BinaryIndexedTree = /** @class */ (function () {
     function BinaryIndexedTree(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }
+    Object.defineProperty(BinaryIndexedTree.prototype, "sumTree", {
+        get: function () {
+            return this._sumTree;
+        },
+        enumerable: false,
+        configurable: true
+    });
     BinaryIndexedTree.lowBit = function (x) {
         return x & (-x);
     };
@@ -63,6 +70,9 @@ var BinaryIndexedTree = /** @class */ (function () {
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
     };
+    BinaryIndexedTree.prototype._setSumTree = function (value) {
+        this._sumTree = value;
+    };
     return BinaryIndexedTree;
 }());
 exports.BinaryIndexedTree = BinaryIndexedTree;

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -23,75 +23,34 @@ export declare enum LoopType {
 }
 export declare class BinaryTreeNode<T> {
     constructor(id: BinaryTreeNodeId, val: T, count?: number);
-    protected _id: BinaryTreeNodeId;
+    private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
-    protected _val: T;
+    private _val;
     get val(): T;
     set val(v: T);
-    protected _left?: BinaryTreeNode<T> | null;
+    private _left?;
     get left(): BinaryTreeNode<T> | null | undefined;
     set left(v: BinaryTreeNode<T> | null | undefined);
-    protected _right?: BinaryTreeNode<T> | null;
+    private _right?;
     get right(): BinaryTreeNode<T> | null | undefined;
     set right(v: BinaryTreeNode<T> | null | undefined);
-    protected _parent: BinaryTreeNode<T> | null | undefined;
+    private _parent;
     get parent(): BinaryTreeNode<T> | null | undefined;
     set parent(v: BinaryTreeNode<T> | null | undefined);
-    protected _familyPosition: FamilyPosition;
+    private _familyPosition;
     get familyPosition(): FamilyPosition;
     set familyPosition(v: FamilyPosition);
-    protected _count: number;
+    private _count;
     get count(): number;
     set count(v: number);
-    protected _height: number;
+    private _height;
     get height(): number;
     set height(v: number);
-    /**
-     * 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.
-     */
-    getId(): BinaryTreeNodeId;
-    /**
-     * 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.
-     */
-    getVal(): T;
-    /**
-     * 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.
-     */
-    getLeft(): BinaryTreeNode<T> | null | undefined;
-    /**
-     * 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.
-     */
-    getRight(): BinaryTreeNode<T> | null | undefined;
-    /**
-     * 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.
-     */
-    getParent(): BinaryTreeNode<T> | null | undefined;
-    /**
-     * 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.
-     */
-    getFamilyPosition(): 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.
-     */
-    getCount(): number;
-    /**
-     * 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.
-     */
-    getHeight(): number;
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
     clone(): BinaryTreeNode<T>;
 }
 export declare class BinaryTree<T> {
-    protected _loopType: LoopType;
-    protected _visitedId: BinaryTreeNodeId[];
-    protected _visitedVal: Array<T>;
-    protected _visitedNode: BinaryTreeNode<T>[];
-    protected _visitedCount: number[];
-    protected _visitedLeftSum: number[];
-    private readonly _autoIncrementId;
-    private _maxId;
-    private readonly _isDuplicatedVal;
     /**
      * The constructor function accepts an optional options object and sets the values of loopType, autoIncrementId, and
      * isDuplicatedVal based on the provided options.
@@ -102,28 +61,30 @@ export declare class BinaryTree<T> {
         autoIncrementId?: boolean;
         isDuplicatedVal?: boolean;
     });
-    protected _root: BinaryTreeNode<T> | null;
+    private _loopType;
+    get loopType(): LoopType;
+    private _visitedId;
+    get visitedId(): BinaryTreeNodeId[];
+    private _visitedVal;
+    get visitedVal(): Array<T>;
+    private _visitedNode;
+    get visitedNode(): BinaryTreeNode<T>[];
+    private _visitedCount;
+    get visitedCount(): number[];
+    private _visitedLeftSum;
+    get visitedLeftSum(): number[];
+    private _autoIncrementId;
+    get autoIncrementId(): boolean;
+    private _maxId;
+    get maxId(): number;
+    private _isDuplicatedVal;
+    get isDuplicatedVal(): boolean;
+    private _root;
     get root(): BinaryTreeNode<T> | null;
-    protected set root(v: BinaryTreeNode<T> | null);
-    protected _size: number;
+    private _size;
     get size(): number;
-    protected set size(v: number);
-    protected _count: number;
+    private _count;
     get count(): number;
-    protected set count(v: number);
-    /**
-     * 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.
-     */
-    getRoot(): BinaryTreeNode<T> | null;
-    /**
-     * 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.
-     */
-    getSize(): number;
-    /**
-     * 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.
-     */
-    getCount(): number;
     /**
      * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
      * null.
@@ -347,6 +308,18 @@ export declare class BinaryTree<T> {
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    protected _setLoopType(value: LoopType): void;
+    protected _setVisitedId(value: BinaryTreeNodeId[]): void;
+    protected _setVisitedVal(value: Array<T>): void;
+    protected _setVisitedNode(value: BinaryTreeNode<T>[]): void;
+    protected setVisitedCount(value: number[]): void;
+    protected _setVisitedLeftSum(value: number[]): void;
+    protected _setAutoIncrementId(value: boolean): void;
+    protected _setMaxId(value: number): void;
+    protected _setIsDuplicatedVal(value: boolean): void;
+    protected _setRoot(v: BinaryTreeNode<T> | null): void;
+    protected _setSize(v: number): void;
+    protected _setCount(v: number): void;
     /**
      * The function resets the values of several arrays used for tracking visited nodes and their properties.
      */

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,54 +151,6 @@ 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.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
         var tempNode = new BinaryTreeNode(swapNode.id, val);
@@ -247,17 +199,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 +273,6 @@ var BinaryTree = /** @class */ (function () {
         get: function () {
             return this._size;
         },
-        set: function (v) {
-            this._size = v;
-        },
         enumerable: false,
         configurable: true
     });
@@ -275,31 +280,9 @@ 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.
@@ -319,10 +302,10 @@ var BinaryTree = /** @class */ (function () {
      * 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.
@@ -371,7 +354,7 @@ var BinaryTree = /** @class */ (function () {
                 existNode.count += count;
                 existNode.val = val;
                 if (needInsert !== null) {
-                    this.count += count;
+                    this._setCount(this.count + count);
                     inserted = existNode;
                 }
             }
@@ -380,10 +363,10 @@ var BinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this.root = val !== null ? new BinaryTreeNode(id, val, count) : null;
+            this._setRoot(val !== null ? new BinaryTreeNode(id, val, count) : null);
             if (needInsert !== null) {
-                this.size = 1;
-                this.count = count;
+                this._setSize(1);
+                this._setCount(count);
             }
             inserted = this.root;
         }
@@ -407,8 +390,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 === null || newNode === void 0 ? void 0 : newNode.count)) !== null && _a !== void 0 ? _a : 0);
                 }
                 return parent.left;
             }
@@ -419,8 +402,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 === null || newNode === void 0 ? void 0 : newNode.count)) !== null && _b !== void 0 ? _b : 0);
                 }
                 return parent.right;
             }
@@ -533,27 +516,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;
@@ -833,7 +816,6 @@ 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>
@@ -907,6 +889,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 +963,7 @@ var BinaryTree = /** @class */ (function () {
                     break;
                 case 'count':
                     cur.count += delta;
-                    _this.count += delta;
+                    _this._setCount(_this.count + delta);
                     break;
                 default:
                     cur.id += delta;
@@ -1338,6 +1321,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.
      */