data-structure-typed 1.19.6 → 1.19.8

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

@@ -16,7 +16,7 @@ export declare abstract class AbstractBinaryTreeNode<T = any, NEIGHBOR extends A
      * @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.
      */
-    constructor(id: BinaryTreeNodeId, val?: T);
+    protected constructor(id: BinaryTreeNodeId, val?: T);
     private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
@@ -54,20 +54,14 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
-    private _autoIncrementId;
-    get autoIncrementId(): boolean;
-    private _maxId;
-    get maxId(): number;
-    private _isMergeDuplicatedVal;
-    get isMergeDuplicatedVal(): boolean;
+    private _isMergeDuplicatedNodeById;
+    get isMergeDuplicatedNodeById(): boolean;
     private _visitedId;
     get visitedId(): BinaryTreeNodeId[];
     private _visitedVal;
-    get visitedVal(): Array<N['val']>;
+    get visitedVal(): N['val'][];
     private _visitedNode;
     get visitedNode(): N[];
-    private _visitedCount;
-    get visitedCount(): number[];
     private _visitedLeftSum;
     get visitedLeftSum(): number[];
     abstract createNode(id: BinaryTreeNodeId, val?: N['val']): N | null;
@@ -89,15 +83,19 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     isEmpty(): boolean;
     /**
-     * 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`.
+     * When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+     * In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
      */
-    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
+    /**
+     * The `add` function adds a new node to a binary tree, either by ID or by creating a new node with a given value.
+     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId`, which
+     * is a number representing the ID of a binary tree node, or it can be a `N` object, which represents a binary tree
+     * node itself. It can also be `null` if no node is specified.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
+     * being added to the binary tree.
+     * @returns The function `add` returns either the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val']): N | null | undefined;
     /**
      * The function adds a new node to the left or right child of a parent node, updating the size of the tree if
      * necessary.
@@ -109,21 +107,25 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
-     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function adds multiple nodes to a tree data structure and returns an array of the inserted nodes or
      * null/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`.
-     */
-    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
-    /**
-     * 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.
+     * @param {(BinaryTreeNodeId|N)[]} idsOrNodes - An array of BinaryTreeNodeId or N objects. These can be either the ID
+     * of a binary tree node or the actual node object itself.
+     * @param {N['val'][]} [data] - Optional array of values to be added to the nodes. If provided, the length of this
+     * array should be the same as the length of the `idsOrNodes` array.
+     * @returns The function `addMany` returns an array of values `(N | null | undefined)[]`.
+     */
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    /**
+     * The `fill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
+     * @param {(BinaryTreeNodeId | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
+     * `BinaryTreeNodeId` or `N` values.
+     * @param {N[] | Array<N['val']>} [data] - The `data` parameter is an optional array of values that will be assigned to
+     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `idsOrNodes`
+     * array. Each value in the `data` array will be assigned to the
+     * @returns The method is returning a boolean value.
      */
-    fill(data: N[] | Array<N['val']>): boolean;
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
     /**
      * 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.
@@ -215,14 +217,12 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
-    isBSTByRooted(node: N | null): boolean;
+    isSubtreeBST(node: N | null): boolean;
     /**
-     * The function checks if a binary tree is a binary search tree.
-     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
-     * search tree (BST).
-     * @returns a boolean value.
+     * The function isBST checks if the binary search tree is valid.
+     * @returns The `isBST()` function is returning a boolean value.
      */
-    isBST(node?: N | null): boolean;
+    isBST(): boolean;
     /**
      * 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
@@ -305,31 +305,14 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @param {N[]} value - N[] is an array of elements of type N.
      */
     protected _setVisitedNode(value: N[]): void;
-    /**
-     * The function sets the value of the visitedCount property.
-     * @param {number[]} value - The value parameter is an array of numbers.
-     */
-    protected setVisitedCount(value: number[]): void;
     /**
      * 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.
      */
     protected _setVisitedLeftSum(value: number[]): void;
     /**
-     * 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.
-     */
-    protected _setAutoIncrementId(value: boolean): void;
-    /**
-     * The function sets the maximum ID value.
-     * @param {number} value - The value parameter is a number that represents the new maximum ID value.
-     */
-    protected _setMaxId(value: number): void;
-    /**
-     * 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
+     * The function sets the value of a protected property called "_isMergeDuplicatedNodeById".
+     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedNodeById
      * property should be set to true or false.
      */
     protected _setIsDuplicatedVal(value: boolean): void;
@@ -345,10 +328,10 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     protected _setSize(v: number): void;
     /**
-     * The function `_resetResults` resets the values of several arrays used for tracking visited nodes and their
+     * The function `_clearResults` resets the values of several arrays used for tracking visited nodes and their
      * properties.
      */
-    protected _resetResults(): void;
+    protected _clearResults(): void;
     /**
      * 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.

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

@@ -113,21 +113,22 @@ class AbstractBinaryTree {
         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._isMergeDuplicatedNodeById = true;
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
-        this._visitedCount = [];
         this._visitedLeftSum = [];
         if (options !== undefined) {
-            const { loopType = types_1.LoopType.ITERATIVE, autoIncrementId = false, isMergeDuplicatedVal = true } = options;
-            this._isMergeDuplicatedVal = isMergeDuplicatedVal;
-            this._autoIncrementId = autoIncrementId;
+            const { loopType = types_1.LoopType.ITERATIVE, isMergeDuplicatedNodeById = true } = options;
+            this._isMergeDuplicatedNodeById = isMergeDuplicatedNodeById;
             this._loopType = loopType;
         }
+        else {
+            this._isMergeDuplicatedNodeById = true;
+            this._loopType = types_1.LoopType.ITERATIVE;
+        }
+        this.clear();
     }
     get root() {
         return this._root;
@@ -138,14 +139,8 @@ class AbstractBinaryTree {
     get loopType() {
         return this._loopType;
     }
-    get autoIncrementId() {
-        return this._autoIncrementId;
-    }
-    get maxId() {
-        return this._maxId;
-    }
-    get isMergeDuplicatedVal() {
-        return this._isMergeDuplicatedVal;
+    get isMergeDuplicatedNodeById() {
+        return this._isMergeDuplicatedNodeById;
     }
     get visitedId() {
         return this._visitedId;
@@ -156,9 +151,6 @@ class AbstractBinaryTree {
     get visitedNode() {
         return this._visitedNode;
     }
-    get visitedCount() {
-        return this._visitedCount;
-    }
     get visitedLeftSum() {
         return this._visitedLeftSum;
     }
@@ -170,19 +162,16 @@ class AbstractBinaryTree {
      * @returns The `destNode` is being returned.
      */
     swapLocation(srcNode, destNode) {
-        const { val, height, id } = destNode;
+        const { id, val, height } = destNode;
         const 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;
-            }
+            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;
     }
@@ -190,9 +179,9 @@ class AbstractBinaryTree {
      * The clear() function resets the root, size, and maxId properties to their initial values.
      */
     clear() {
-        this._setRoot(null);
-        this._setSize(0);
-        this._setMaxId(-1);
+        this._root = null;
+        this._size = 0;
+        this._clearResults();
     }
     /**
      * The function checks if the size of an object is equal to zero and returns a boolean value.
@@ -202,15 +191,19 @@ class AbstractBinaryTree {
         return this.size === 0;
     }
     /**
-     * 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`.
+     * When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+     * In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
+     */
+    /**
+     * The `add` function adds a new node to a binary tree, either by ID or by creating a new node with a given value.
+     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId`, which
+     * is a number representing the ID of a binary tree node, or it can be a `N` object, which represents a binary tree
+     * node itself. It can also be `null` if no node is specified.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
+     * being added to the binary tree.
+     * @returns The function `add` returns either the inserted node (`N`), `null`, or `undefined`.
      */
-    add(id, val, count) {
+    add(idOrNode, val) {
         const _bfs = (root, newNode) => {
             const queue = [root];
             while (queue.length > 0) {
@@ -229,25 +222,37 @@ class AbstractBinaryTree {
             }
             return;
         };
-        let inserted;
-        const needInsert = val !== null ? this.createNode(id, val) : null;
-        const existNode = val !== null ? this.get(id, 'id') : null;
+        let inserted, needInsert;
+        if (idOrNode === null) {
+            needInsert = null;
+        }
+        else if (typeof idOrNode === 'number') {
+            needInsert = this.createNode(idOrNode, val);
+        }
+        else if (idOrNode instanceof AbstractBinaryTreeNode) {
+            needInsert = idOrNode;
+        }
+        else {
+            return;
+        }
+        const existNode = idOrNode ? this.get(idOrNode, 'id') : undefined;
         if (this.root) {
             if (existNode) {
-                existNode.val = val !== null && val !== void 0 ? val : id;
-                if (needInsert !== null) {
-                    inserted = existNode;
-                }
+                existNode.val = val;
+                inserted = existNode;
             }
             else {
                 inserted = _bfs(this.root, needInsert);
             }
         }
         else {
-            this._setRoot(val !== null ? this.createNode(id, val) : null);
+            this._setRoot(needInsert);
             if (needInsert !== null) {
                 this._setSize(1);
             }
+            else {
+                this._setSize(0);
+            }
             inserted = this.root;
         }
         return inserted;
@@ -263,22 +268,18 @@ class AbstractBinaryTree {
      */
     addTo(newNode, parent) {
         if (parent) {
+            // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+            // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
             if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.left = newNode;
-                if (newNode !== null) {
+                if (newNode) {
                     this._setSize(this.size + 1);
                 }
                 return parent.left;
             }
             else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.right = newNode;
-                if (newNode !== null) {
+                if (newNode) {
                     this._setSize(this.size + 1);
                 }
                 return parent.right;
@@ -292,77 +293,58 @@ class AbstractBinaryTree {
         }
     }
     /**
-     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes or
+     * The `addMany` function adds multiple nodes to a tree data structure and returns an array of the inserted nodes or
      * null/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`.
+     * @param {(BinaryTreeNodeId|N)[]} idsOrNodes - An array of BinaryTreeNodeId or N objects. These can be either the ID
+     * of a binary tree node or the actual node object itself.
+     * @param {N['val'][]} [data] - Optional array of values to be added to the nodes. If provided, the length of this
+     * array should be the same as the length of the `idsOrNodes` array.
+     * @returns The function `addMany` returns an array of values `(N | null | undefined)[]`.
      */
-    addMany(data) {
+    addMany(idsOrNodes, data) {
         var _a;
         // TODO not sure addMany not be run multi times
         const inserted = [];
         const map = new Map();
-        if (this.isMergeDuplicatedVal) {
-            for (const nodeOrId of data)
-                map.set(nodeOrId, ((_a = map.get(nodeOrId)) !== null && _a !== void 0 ? _a : 0) + 1);
+        if (this.isMergeDuplicatedNodeById) {
+            for (const idOrNode of idsOrNodes)
+                map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
         }
-        for (const nodeOrId of data) {
-            if (nodeOrId instanceof AbstractBinaryTreeNode) {
-                inserted.push(this.add(nodeOrId.id, nodeOrId.val));
-                continue;
-            }
-            if (nodeOrId === null) {
-                inserted.push(this.add(NaN, null, 0));
+        for (let i = 0; i < idsOrNodes.length; i++) {
+            const idOrNode = idsOrNodes[i];
+            if (idOrNode instanceof AbstractBinaryTreeNode) {
+                inserted.push(this.add(idOrNode.id, idOrNode.val));
                 continue;
             }
-            // TODO will this cause an issue?
-            const count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
-            let newId;
-            if (typeof nodeOrId === 'number') {
-                newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
-            }
-            else if (nodeOrId instanceof Object) {
-                if (this.autoIncrementId) {
-                    newId = this.maxId + 1;
-                }
-                else {
-                    if (Object.keys(nodeOrId).includes('id')) {
-                        newId = nodeOrId.id;
-                    }
-                    else {
-                        console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
-                        continue;
-                    }
-                }
-            }
-            else {
-                console.warn(nodeOrId, ` is not added`);
+            if (idOrNode === null) {
+                inserted.push(this.add(null));
                 continue;
             }
-            if (this.isMergeDuplicatedVal) {
-                if (map.has(nodeOrId)) {
-                    inserted.push(this.add(newId, nodeOrId, count));
-                    map.delete(nodeOrId);
+            const val = data === null || data === void 0 ? void 0 : data[i];
+            if (this.isMergeDuplicatedNodeById) {
+                if (map.has(idOrNode)) {
+                    inserted.push(this.add(idOrNode, val));
+                    map.delete(idOrNode);
                 }
             }
             else {
-                inserted.push(this.add(newId, nodeOrId, 1));
+                inserted.push(this.add(idOrNode, val));
             }
-            this._setMaxId(newId);
         }
         return inserted;
     }
     /**
-     * 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.
+     * The `fill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
+     * @param {(BinaryTreeNodeId | N)[]} idsOrNodes - The `idsOrNodes` parameter is an array that can contain either
+     * `BinaryTreeNodeId` or `N` values.
+     * @param {N[] | Array<N['val']>} [data] - The `data` parameter is an optional array of values that will be assigned to
+     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `idsOrNodes`
+     * array. Each value in the `data` array will be assigned to the
+     * @returns The method is returning a boolean value.
      */
-    fill(data) {
+    fill(idsOrNodes, data) {
         this.clear();
-        return data.length === this.addMany(data).length;
+        return idsOrNodes.length === this.addMany(idsOrNodes, data).length;
     }
     /**
      * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
@@ -588,6 +570,7 @@ class AbstractBinaryTree {
      */
     has(nodeProperty, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        // TODO may support finding node by value equal
         return this.getNodes(nodeProperty, propertyName).length > 0;
     }
     /**
@@ -604,6 +587,7 @@ class AbstractBinaryTree {
     get(nodeProperty, propertyName) {
         var _a;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        // TODO may support finding node by value equal
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
@@ -613,6 +597,7 @@ class AbstractBinaryTree {
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
     getPathToRoot(node) {
+        // TODO to support get path through passing id
         const result = [];
         while (node.parent) {
             result.unshift(node);
@@ -666,6 +651,7 @@ class AbstractBinaryTree {
      * function returns `null`.
      */
     getRightMost(node) {
+        // TODO support get right most by passing id in
         node = node !== null && node !== void 0 ? node : this.root;
         if (!node)
             return node;
@@ -692,7 +678,7 @@ class AbstractBinaryTree {
      * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
      * @returns a boolean value.
      */
-    isBSTByRooted(node) {
+    isSubtreeBST(node) {
         // TODO there is a bug
         if (!node)
             return true;
@@ -724,13 +710,11 @@ class AbstractBinaryTree {
         }
     }
     /**
-     * The function checks if a binary tree is a binary search tree.
-     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
-     * search tree (BST).
-     * @returns a boolean value.
+     * The function isBST checks if the binary search tree is valid.
+     * @returns The `isBST()` function is returning a boolean value.
      */
-    isBST(node) {
-        return this.isBSTByRooted(this.root);
+    isBST() {
+        return this.isSubtreeBST(this.root);
     }
     /**
      * The function calculates the size of a subtree by traversing it either recursively or iteratively.
@@ -739,6 +723,7 @@ class AbstractBinaryTree {
      * @returns the size of the subtree rooted at `subTreeRoot`.
      */
     getSubTreeSize(subTreeRoot) {
+        // TODO support id passed in
         let size = 0;
         if (!subTreeRoot)
             return size;
@@ -868,7 +853,7 @@ class AbstractBinaryTree {
      */
     BFS(nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
-        this._resetResults();
+        this._clearResults();
         const queue = [this.root];
         while (queue.length !== 0) {
             const cur = queue.shift();
@@ -896,7 +881,7 @@ class AbstractBinaryTree {
     DFS(pattern, nodeOrPropertyName) {
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
-        this._resetResults();
+        this._clearResults();
         const _traverse = (node) => {
             switch (pattern) {
                 case 'in':
@@ -939,7 +924,7 @@ class AbstractBinaryTree {
     DFSIterative(pattern, nodeOrPropertyName) {
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
-        this._resetResults();
+        this._clearResults();
         if (!this.root)
             return this._getResultByPropertyName(nodeOrPropertyName);
         // 0: visit, 1: print
@@ -995,7 +980,7 @@ class AbstractBinaryTree {
         node = node || this.root;
         if (!node)
             return [];
-        this._resetResults();
+        this._clearResults();
         const queue = [node];
         while (queue.length > 0) {
             const cur = queue.shift();
@@ -1104,7 +1089,7 @@ class AbstractBinaryTree {
             return [];
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
-        this._resetResults();
+        this._clearResults();
         let cur = this.root;
         const _reverseEdge = (node) => {
             let pre = null;
@@ -1213,13 +1198,6 @@ class AbstractBinaryTree {
     _setVisitedNode(value) {
         this._visitedNode = value;
     }
-    /**
-     * The function sets the value of the visitedCount property.
-     * @param {number[]} value - The value parameter is an array of numbers.
-     */
-    setVisitedCount(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.
@@ -1228,28 +1206,12 @@ class AbstractBinaryTree {
         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.
-     */
-    _setAutoIncrementId(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.
-     */
-    _setMaxId(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
+     * The function sets the value of a protected property called "_isMergeDuplicatedNodeById".
+     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedNodeById
      * property should be set to true or false.
      */
     _setIsDuplicatedVal(value) {
-        this._isMergeDuplicatedVal = value;
+        this._isMergeDuplicatedNodeById = 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
@@ -1270,10 +1232,10 @@ class AbstractBinaryTree {
         this._size = v;
     }
     /**
-     * The function `_resetResults` resets the values of several arrays used for tracking visited nodes and their
+     * The function `_clearResults` resets the values of several arrays used for tracking visited nodes and their
      * properties.
      */
-    _resetResults() {
+    _clearResults() {
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];

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

@@ -9,6 +9,7 @@ import { BST, BSTNode } from './bst';
 import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
 import { IAVLTree, IAVLTreeNode } from '../interfaces';
 export declare class AVLTreeNode<T = any, NEIGHBOR extends AVLTreeNode<T, NEIGHBOR> = AVLTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IAVLTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
 export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
     /**