data-structure-typed 1.18.7 → 1.18.8

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

@@ -48,7 +48,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
      * value `val` appears in the binary tree node. If the `count` parameter is not provided, it defaults to 1.
      */
     function AbstractBinaryTreeNode(id, val, count) {
-        this._familyPosition = types_1.FamilyPosition.ROOT;
         this._count = 1;
         this._height = 0;
         this._id = id;
@@ -82,7 +81,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.LEFT;
             }
             this._left = v;
         },
@@ -96,7 +94,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         set: function (v) {
             if (v) {
                 v.parent = this;
-                v.familyPosition = types_1.FamilyPosition.RIGHT;
             }
             this._right = v;
         },
@@ -113,16 +110,6 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
-        get: function () {
-            return this._familyPosition;
-        },
-        set: function (v) {
-            this._familyPosition = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(AbstractBinaryTreeNode.prototype, "count", {
         get: function () {
             return this._count;
@@ -143,28 +130,63 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
+        get: function () {
+            var that = this;
+            if (that.parent) {
+                if (that.parent.left === that) {
+                    if (that.left || that.right) {
+                        return types_1.FamilyPosition.ROOT_LEFT;
+                    }
+                    else {
+                        return types_1.FamilyPosition.LEFT;
+                    }
+                }
+                else if (that.parent.right === that) {
+                    if (that.left || that.right) {
+                        return types_1.FamilyPosition.ROOT_RIGHT;
+                    }
+                    else {
+                        return types_1.FamilyPosition.RIGHT;
+                    }
+                }
+                else {
+                    return types_1.FamilyPosition.MAL_NODE;
+                }
+            }
+            else {
+                if (that.left || that.right) {
+                    return types_1.FamilyPosition.ROOT;
+                }
+                else {
+                    return types_1.FamilyPosition.ISOLATED;
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * The function swaps the location of two nodes in a binary tree.
-     * @param {FAMILY} swapNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
+     * @param {FAMILY} destNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
      * @returns the `swapNode` object after swapping its properties with the properties of `this` object.
      */
-    AbstractBinaryTreeNode.prototype.swapLocation = function (swapNode) {
-        var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = this.createNode(swapNode.id, val);
+    AbstractBinaryTreeNode.prototype.swapLocation = function (destNode) {
+        var val = destNode.val, count = destNode.count, height = destNode.height, id = destNode.id;
+        var tempNode = this.createNode(id, val, count);
+        tempNode.height = height;
         if (tempNode instanceof AbstractBinaryTreeNode) {
-            tempNode.val = val;
-            tempNode.count = count;
-            tempNode.height = height;
-            swapNode.id = this.id;
-            swapNode.val = this.val;
-            swapNode.count = this.count;
-            swapNode.height = this.height;
+            // TODO should we consider the left, right children?
+            destNode.id = this.id;
+            destNode.val = this.val;
+            destNode.count = this.count;
+            destNode.height = this.height;
             this.id = tempNode.id;
             this.val = tempNode.val;
             this.count = tempNode.count;
             this.height = tempNode.height;
         }
-        return swapNode;
+        return destNode;
     };
     /**
      * The `clone` function returns a new instance of the `FAMILY` class with the same `id`, `val`, and `count` properties.
@@ -192,13 +214,13 @@ var AbstractBinaryTree = /** @class */ (function () {
         this._visitedLeftSum = [];
         this._autoIncrementId = false;
         this._maxId = -1;
-        this._isDuplicatedVal = false;
+        this._isMergeDuplicatedVal = true;
         this._root = null;
         this._size = 0;
         this._count = 0;
         if (options !== undefined) {
-            var _a = options.loopType, loopType = _a === void 0 ? types_1.LoopType.ITERATIVE : _a, _b = options.autoIncrementId, autoIncrementId = _b === void 0 ? false : _b, _c = options.isDuplicatedVal, isDuplicatedVal = _c === void 0 ? false : _c;
-            this._isDuplicatedVal = isDuplicatedVal;
+            var _a = options.loopType, loopType = _a === void 0 ? types_1.LoopType.ITERATIVE : _a, _b = options.autoIncrementId, autoIncrementId = _b === void 0 ? false : _b, _c = options.isMergeDuplicatedVal, isMergeDuplicatedVal = _c === void 0 ? true : _c;
+            this._isMergeDuplicatedVal = isMergeDuplicatedVal;
             this._autoIncrementId = autoIncrementId;
             this._loopType = loopType;
         }
@@ -259,9 +281,9 @@ var AbstractBinaryTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(AbstractBinaryTree.prototype, "isDuplicatedVal", {
+    Object.defineProperty(AbstractBinaryTree.prototype, "isMergeDuplicatedVal", {
         get: function () {
-            return this._isDuplicatedVal;
+            return this._isMergeDuplicatedVal;
         },
         enumerable: false,
         configurable: true
@@ -336,7 +358,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             return;
         };
         var inserted;
-        var needInsert = val !== null ? this.createNode(id, val !== null && val !== void 0 ? val : id, count) : null;
+        var needInsert = val !== null ? this.createNode(id, val, count) : null;
         var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
@@ -352,7 +374,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this._setRoot(val !== null ? this.createNode(id, val !== null && val !== void 0 ? val : id, count) : null);
+            this._setRoot(val !== null ? this.createNode(id, val, count) : null);
             if (needInsert !== null) {
                 this._setSize(1);
                 this._setCount(count);
@@ -376,7 +398,6 @@ var AbstractBinaryTree = /** @class */ (function () {
             if (parent.left === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.LEFT;
                 }
                 parent.left = newNode;
                 if (newNode !== null) {
@@ -388,7 +409,6 @@ var AbstractBinaryTree = /** @class */ (function () {
             else if (parent.right === undefined) {
                 if (newNode) {
                     newNode.parent = parent;
-                    newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                 }
                 parent.right = newNode;
                 if (newNode !== null) {
@@ -415,13 +435,14 @@ var AbstractBinaryTree = /** @class */ (function () {
     AbstractBinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
         var _c;
+        // TODO not sure addMany not be run multi times
         var inserted = [];
         var map = new Map();
-        if (!this._isDuplicatedVal) {
+        if (this.isMergeDuplicatedVal) {
             try {
                 for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
-                    var i = data_1_1.value;
-                    map.set(i, ((_c = map.get(i)) !== null && _c !== void 0 ? _c : 0) + 1);
+                    var nodeOrId = data_1_1.value;
+                    map.set(nodeOrId, ((_c = map.get(nodeOrId)) !== null && _c !== void 0 ? _c : 0) + 1);
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -434,53 +455,49 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
         try {
             for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
-                var item = data_2_1.value;
+                var nodeOrId = data_2_1.value;
+                if (nodeOrId instanceof AbstractBinaryTreeNode) {
+                    inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+                    continue;
+                }
+                if (nodeOrId === null) {
+                    inserted.push(this.add(NaN, null, 0));
+                    continue;
+                }
                 // TODO will this cause an issue?
-                var count = this._isDuplicatedVal ? 1 : map.get(item);
-                if (item instanceof AbstractBinaryTreeNode) {
-                    inserted.push(this.add(item.id, item.val, item.count));
+                var count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
+                var newId = void 0;
+                if (typeof nodeOrId === 'number') {
+                    newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
                 }
-                else if (typeof item === 'number') {
-                    if (!this._autoIncrementId) {
-                        if (!this._isDuplicatedVal) {
-                            if (map.get(item) !== undefined) {
-                                inserted.push(this.add(item, item, count));
-                                map.delete(item);
-                            }
+                else if (nodeOrId instanceof Object) {
+                    if (this.autoIncrementId) {
+                        newId = this.maxId + 1;
+                    }
+                    else {
+                        if (Object.keys(nodeOrId).includes('id')) {
+                            newId = nodeOrId.id;
                         }
                         else {
-                            inserted.push(this.add(item, item, 1));
+                            console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
+                            continue;
                         }
                     }
                 }
-                else if (item instanceof Object) {
-                    if (!this._isDuplicatedVal) {
-                        if (map.has(item)) {
-                            var newId = void 0;
-                            if (!this._autoIncrementId) {
-                                if (Object.keys(item).includes('id')) {
-                                    newId = item.id;
-                                }
-                                else {
-                                    console.warn('Object value must has an id property when the autoIncrementId is false');
-                                    break;
-                                }
-                            }
-                            else {
-                                newId = this.maxId + 1;
-                                this._setMaxId(newId);
-                            }
-                            inserted.push(this.add(newId, item, count));
-                            map.delete(item);
-                        }
-                    }
-                    else {
-                        inserted.push(this.add(++this._maxId, item, 1));
+                else {
+                    console.warn(nodeOrId, " is not added");
+                    continue;
+                }
+                if (this.isMergeDuplicatedVal) {
+                    if (map.has(nodeOrId)) {
+                        inserted.push(this.add(newId, nodeOrId, count));
+                        map.delete(nodeOrId);
                     }
                 }
-                else if (item === null) {
-                    inserted.push(this.add(Number.MAX_SAFE_INTEGER, item, 0));
+                else {
+                    inserted.push(this.add(newId, nodeOrId, 1));
                 }
+                this._setMaxId(newId);
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -504,62 +521,76 @@ var AbstractBinaryTree = /** @class */ (function () {
         return data.length === this.addMany(data).length;
     };
     /**
-     * The function removes a node from a binary tree and returns information about the deleted node.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to remove.
-     * It is of type `BinaryTreeNodeId`.
+     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * node that needs to be balanced.
+     * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
-     * not be decremented and the overall count of the binary tree will not be updated. If `
-     * @returns An array of objects is being returned. Each object in the array has two properties: "deleted" and
-     * "needBalanced". The "deleted" property contains the deleted node or undefined if no node was deleted. The
-     * "needBalanced" property is always null.
+     * not be taken into account when removing it. If `ignoreCount` is set to `false
+     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    AbstractBinaryTree.prototype.remove = function (id, ignoreCount) {
-        var nodes = this.getNodes(id, 'id', true);
-        var node = nodes[0];
-        if (!node)
-            node = undefined;
-        else if (node.count > 1 && !ignoreCount) {
-            node.count--;
+    AbstractBinaryTree.prototype.remove = function (nodeOrId, ignoreCount) {
+        var bstDeletedResult = [];
+        if (!this.root)
+            return bstDeletedResult;
+        var curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        if (!curr)
+            return bstDeletedResult;
+        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        var needBalanced = null, orgCurrent = curr;
+        if (curr.count > 1 && !ignoreCount) {
+            curr.count--;
             this._setCount(this.count - 1);
         }
-        else if (node instanceof AbstractBinaryTreeNode) {
-            var _a = __read(this.getSubTreeSizeAndCount(node), 2), subSize = _a[0], subCount = _a[1];
-            switch (node.familyPosition) {
-                case 0:
-                    this._setSize(this.size - subSize);
-                    this._setCount(this.count - subCount);
-                    node = undefined;
-                    break;
-                case 1:
-                    if (node.parent) {
-                        this._setSize(this.size - subSize);
-                        this._setCount(this.count - subCount);
-                        node.parent.left = null;
+        else {
+            if (!curr.left) {
+                if (!parent) {
+                    if (curr.right !== undefined)
+                        this._setRoot(curr.right);
+                }
+                else {
+                    var fp = curr.familyPosition;
+                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                        parent.left = curr.right;
                     }
-                    break;
-                case 2:
-                    if (node.parent) {
-                        this._setSize(this.size - subSize);
-                        this._setCount(this.count - subCount);
-                        node.parent.right = null;
+                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                        parent.right = curr.right;
                     }
-                    break;
+                    needBalanced = parent;
+                }
+            }
+            else {
+                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                if (leftSubTreeRightMost) {
+                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    orgCurrent = curr.swapLocation(leftSubTreeRightMost);
+                    if (parentOfLeftSubTreeMax) {
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                        else
+                            parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        needBalanced = parentOfLeftSubTreeMax;
+                    }
+                }
             }
+            this._setSize(this.size - 1);
+            this._setCount(this.count - orgCurrent.count);
         }
-        return [{ deleted: node, needBalanced: null }];
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        return bstDeletedResult;
     };
     /**
-     * The function calculates the depth of a binary tree node by traversing its parent nodes.
-     * @param node - N - This is the node for which we want to calculate the depth. It is a generic type,
-     * meaning it can represent any type of data that we want to store in the node.
-     * @returns The depth of the given binary tree node.
+     * The function calculates the depth of a node in a binary tree.
+     * @param {N | BinaryTreeNodeId | null} beginRoot - The `beginRoot` parameter can be one of the following:
+     * @returns the depth of the given node or binary tree.
      */
-    AbstractBinaryTree.prototype.getDepth = function (node) {
+    AbstractBinaryTree.prototype.getDepth = function (beginRoot) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
         var depth = 0;
-        while (node.parent) {
+        while (beginRoot === null || beginRoot === void 0 ? void 0 : beginRoot.parent) {
             depth++;
-            node = node.parent;
+            beginRoot = beginRoot.parent;
         }
         return depth;
     };
@@ -574,6 +605,8 @@ var AbstractBinaryTree = /** @class */ (function () {
     AbstractBinaryTree.prototype.getHeight = function (beginRoot) {
         var _a, _b, _c;
         beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
         if (!beginRoot)
             return -1;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -762,24 +795,28 @@ var AbstractBinaryTree = /** @class */ (function () {
         return result;
     };
     /**
-     * The `getLeftMost` function returns the leftmost node in a binary tree, either recursively or iteratively using tail
-     * recursion optimization.
-     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
-     * | null`. It represents the starting node from which to find the leftmost node in a binary tree. If no node is
-     * provided, the function will use the root node of the binary tree.
-     * @returns The `getLeftMost` function returns the leftmost node in a binary tree.
+     * The `getLeftMost` function returns the leftmost node in a binary tree, starting from a specified node or the root if
+     * no node is specified.
+     * @param {N | BinaryTreeNodeId | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
+     * generic type representing a node in a binary tree), `BinaryTreeNodeId` (a type representing the ID of a binary tree
+     * node), or `null`.
+     * @returns The function `getLeftMost` returns the leftmost node in a binary tree. If the `beginRoot` parameter is
+     * provided, it starts the traversal from that node. If `beginRoot` is not provided or is `null`, it starts the
+     * traversal from the root of the binary tree. If there are no nodes in the binary tree, it returns `null`.
      */
-    AbstractBinaryTree.prototype.getLeftMost = function (node) {
-        node = node !== null && node !== void 0 ? node : this.root;
-        if (!node)
-            return node;
+    AbstractBinaryTree.prototype.getLeftMost = function (beginRoot) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot, 'id');
+        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+        if (!beginRoot)
+            return beginRoot;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_2 = function (cur) {
                 if (!cur.left)
                     return cur;
                 return _traverse_2(cur.left);
             };
-            return _traverse_2(node);
+            return _traverse_2(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
@@ -788,7 +825,7 @@ var AbstractBinaryTree = /** @class */ (function () {
                     return cur;
                 return _traverse_3.cont(cur.left);
             });
-            return _traverse_3(node);
+            return _traverse_3(beginRoot);
         }
     };
     /**
@@ -827,6 +864,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.isBSTByRooted = function (node) {
+        // TODO there is a bug
         if (!node)
             return true;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -912,6 +950,8 @@ var AbstractBinaryTree = /** @class */ (function () {
      */
     AbstractBinaryTree.prototype.subTreeSum = function (subTreeRoot, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return 0;
         var sum = 0;
@@ -953,17 +993,21 @@ var AbstractBinaryTree = /** @class */ (function () {
         return sum;
     };
     /**
-     * The function `subTreeAdd` adds a specified delta value to a property of each node in a binary tree.
-     * @param subTreeRoot - The `subTreeRoot` parameter is the root node of the subtree where the values will be modified.
+     * The function `subTreeAdd` adds a delta value to a specified property of each node in a subtree.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
+     * tree or the ID of a binary tree node. It can also be `null` if there is no subtree root.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each node in the subtree should be increased or decreased.
+     * each node in the subtree should be incremented or decremented.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the `BinaryTreeNode` that should be modified. It defaults to `'id'` if not provided.
-     * @returns a boolean value, which is `true`.
+     * specifies the property of the binary tree node that should be modified. It can be either 'id' or 'count'. If no
+     * value is provided for `propertyName`, it defaults to 'id'.
+     * @returns a boolean value.
      */
     AbstractBinaryTree.prototype.subTreeAdd = function (subTreeRoot, delta, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
         if (!subTreeRoot)
             return false;
         var _addByProperty = function (cur) {
@@ -1356,12 +1400,11 @@ var AbstractBinaryTree = /** @class */ (function () {
         this._maxId = value;
     };
     AbstractBinaryTree.prototype._setIsDuplicatedVal = function (value) {
-        this._isDuplicatedVal = value;
+        this._isMergeDuplicatedVal = value;
     };
     AbstractBinaryTree.prototype._setRoot = function (v) {
         if (v) {
-            v.parent = null;
-            v.familyPosition = types_1.FamilyPosition.ROOT;
+            v.parent = undefined;
         }
         this._root = v;
     };

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

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId, RecursiveAVLTreeNode } from '../types';
+import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
 import { IAVLTree, IAVLTreeNode } from '../interfaces';
-export declare class AVLTreeNode<T, FAMILY extends AVLTreeNode<T, FAMILY> = RecursiveAVLTreeNode<T>> extends BSTNode<T, FAMILY> implements IAVLTreeNode<T, FAMILY> {
+export declare class AVLTreeNode<T = any, FAMILY extends AVLTreeNode<T, FAMILY> = AVLTreeNodeNested<T>> extends BSTNode<T, FAMILY> implements IAVLTreeNode<T, FAMILY> {
     createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
-export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode<number>> extends BST<N> implements IAVLTree<N> {
+export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
     constructor(options?: AVLTreeOptions);
     createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
     /**
@@ -26,7 +26,7 @@ export declare class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode<nu
      * to `1`, indicating that the value should be inserted once.
      * @returns The method is returning either an N object or null.
      */
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
     /**
      * The function overrides the remove method of the Binary Search Tree class, performs the removal operation, and
      * then balances the tree if necessary.

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

@@ -41,7 +41,7 @@ var AVLTreeNode = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     AVLTreeNode.prototype.createNode = function (id, val, count) {
-        return new AVLTreeNode(id, (val === undefined ? id : val), count);
+        return new AVLTreeNode(id, val, count);
     };
     return AVLTreeNode;
 }(bst_1.BSTNode));
@@ -52,7 +52,7 @@ var AVLTree = /** @class */ (function (_super) {
         return _super.call(this, options) || this;
     }
     AVLTree.prototype.createNode = function (id, val, count) {
-        return new AVLTreeNode(id, (val === undefined ? id : val), count);
+        return new AVLTreeNode(id, val, count);
     };
     /**
      * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, RecursiveBinaryTreeNode } from '../types';
+import type { BinaryTreeNodeId, BinaryTreeNodeNested } from '../types';
 import { BinaryTreeOptions } from '../types';
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
 import { IBinaryTree, IBinaryTreeNode } from '../interfaces/binary-tree';
-export declare class BinaryTreeNode<T = number, FAMILY extends BinaryTreeNode<T, FAMILY> = RecursiveBinaryTreeNode<T>> extends AbstractBinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+export declare class BinaryTreeNode<T = any, FAMILY extends BinaryTreeNode<T, FAMILY> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
     /**
      * The function creates a new binary tree node with an optional value and count, and returns it as a specified type.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
@@ -25,7 +25,7 @@ export declare class BinaryTreeNode<T = number, FAMILY extends BinaryTreeNode<T,
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
     /**
      * The constructor function accepts an optional options object and sets the values of loopType, autoIncrementId, and
-     * isDuplicatedVal based on the provided options.
+     * isMergeDuplicatedVal based on the provided options.
      * @param [options] - An optional object that can contain the following properties:
      */
     constructor(options?: BinaryTreeOptions);

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

@@ -40,7 +40,7 @@ var BinaryTreeNode = /** @class */ (function (_super) {
      * @returns a new instance of the BinaryTreeNode class, casted as the FAMILY type.
      */
     BinaryTreeNode.prototype.createNode = function (id, val, count) {
-        return new BinaryTreeNode(id, (val === undefined ? id : val), count);
+        return new BinaryTreeNode(id, val, count);
     };
     return BinaryTreeNode;
 }(abstract_binary_tree_1.AbstractBinaryTreeNode));
@@ -49,11 +49,11 @@ var BinaryTree = /** @class */ (function (_super) {
     __extends(BinaryTree, _super);
     /**
      * The constructor function accepts an optional options object and sets the values of loopType, autoIncrementId, and
-     * isDuplicatedVal based on the provided options.
+     * isMergeDuplicatedVal based on the provided options.
      * @param [options] - An optional object that can contain the following properties:
      */
     function BinaryTree(options) {
-        return _super.call(this) || this;
+        return _super.call(this, options) || this;
     }
     /**
      * The function creates a new binary tree node with the given id, value, and count if the value is not null, otherwise
@@ -67,7 +67,7 @@ var BinaryTree = /** @class */ (function (_super) {
      * @returns a BinaryTreeNode object if the value is not null, otherwise it returns null.
      */
     BinaryTree.prototype.createNode = function (id, val, count) {
-        return new BinaryTreeNode(id, val === undefined ? id : val, count);
+        return new BinaryTreeNode(id, val, count);
     };
     return BinaryTree;
 }(abstract_binary_tree_1.AbstractBinaryTree));