data-structure-typed 1.18.6 → 1.18.8

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

@@ -6,13 +6,14 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId, RecursiveAVLTreeNode } from '../types';
-import { IBinaryTreeNode } from '../interfaces';
-export declare class AVLTreeNode<T, FAMILY extends AVLTreeNode<T, FAMILY> = RecursiveAVLTreeNode<T>> extends BSTNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+import type { AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
+import { IAVLTree, IAVLTreeNode } from '../interfaces';
+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> {
+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;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
     /**
      * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
@@ -25,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

@@ -40,6 +40,9 @@ var AVLTreeNode = /** @class */ (function (_super) {
     function AVLTreeNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    AVLTreeNode.prototype.createNode = function (id, val, count) {
+        return new AVLTreeNode(id, val, count);
+    };
     return AVLTreeNode;
 }(bst_1.BSTNode));
 exports.AVLTreeNode = AVLTreeNode;
@@ -48,9 +51,8 @@ var AVLTree = /** @class */ (function (_super) {
     function AVLTree(options) {
         return _super.call(this, options) || this;
     }
-    AVLTree.prototype._createNode = function (id, val, count) {
-        var node = new AVLTreeNode(id, val, count);
-        return node;
+    AVLTree.prototype.createNode = function (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,17 +5,27 @@
  * @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 { IBinaryTree, IBinaryTreeNode } from '../interfaces';
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
-export declare class BinaryTreeNode<T = number, FAMILY extends BinaryTreeNode<T, FAMILY> = RecursiveBinaryTreeNode<T>> extends AbstractBinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
+import { IBinaryTree, IBinaryTreeNode } from '../interfaces/binary-tree';
+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
+     * `BinaryTreeNodeId`, which could be a string or a number depending on how you want to identify your nodes.
+     * @param {T} [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the
+     * value stored in the node.
+     * @param {number} [count] - The count parameter is an optional parameter that represents the number of times the value
+     * appears in the binary tree node.
+     * @returns a new instance of the BinaryTreeNode class, casted as the FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 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);
@@ -30,5 +40,5 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * 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.
      */
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -29,8 +29,18 @@ var BinaryTreeNode = /** @class */ (function (_super) {
     function BinaryTreeNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    BinaryTreeNode.prototype._createNode = function (id, val, count) {
-        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    /**
+     * 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
+     * `BinaryTreeNodeId`, which could be a string or a number depending on how you want to identify your nodes.
+     * @param {T} [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the
+     * value stored in the node.
+     * @param {number} [count] - The count parameter is an optional parameter that represents the number of times the value
+     * appears in the binary tree node.
+     * @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, count);
     };
     return BinaryTreeNode;
 }(abstract_binary_tree_1.AbstractBinaryTreeNode));
@@ -39,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
@@ -56,9 +66,8 @@ var BinaryTree = /** @class */ (function (_super) {
      * 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) {
-        var node = new BinaryTreeNode(id, val, count);
-        return node;
+    BinaryTree.prototype.createNode = function (id, val, count) {
+        return new BinaryTreeNode(id, val, count);
     };
     return BinaryTree;
 }(abstract_binary_tree_1.AbstractBinaryTree));

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

@@ -5,19 +5,40 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, RecursiveBSTNode } from '../types';
-import { BinaryTreeDeletedResult, BSTOptions, CP } from '../types';
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested } from '../types';
+import { BSTOptions, CP } from '../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+import { IBST, IBSTNode } from '../interfaces';
+export declare class BSTNode<T = any, FAMILY extends BSTNode<T, FAMILY> = BSTNodeNested<T>> extends BinaryTreeNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
+    /**
+     * The function creates a new binary search tree node with the specified id, value, and count.
+     * @param {BinaryTreeNodeId} id - The id parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The "val" parameter represents the value that will be stored in the binary tree node. It is an
+     * optional parameter, meaning it can be omitted when calling the "createNode" function.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary
+     * search tree node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
-export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BinaryTree<N> implements IBinaryTree<N> {
+export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**
      * The constructor function accepts an optional options object and sets the comparator property if provided.
      * @param [options] - An optional object that can contain the following properties:
      */
     constructor(options?: BSTOptions);
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    /**
+     * The function creates a new binary search tree node with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`.
+     * @param {N['val'] | null} [val] - The `val` parameter is the value that will be stored in the node. It can be of any
+     * type `N['val']` or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of occurrences
+     * of a particular value in the binary search tree node.
+     * @returns a new instance of the BSTNode class, casted as type N.
+     */
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
      * the ID matches, and returns the inserted node.
@@ -30,7 +51,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * inserted once.
      * @returns The method `add` returns a `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 `get` function returns the first node in a binary search tree that matches the given property value or name.
      * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
@@ -49,18 +70,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * greater than, it returns the ID of the leftmost node. Otherwise, it also returns the ID of the rightmost node. If
      * there are no nodes in
      */
-    lastKey(): number;
-    /**
-     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
-     * the deleted node and any nodes that need to be balanced.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
-     * from the binary search tree.
-     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
-     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
-     * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<N>` objects.
-     */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    lastKey(): BinaryTreeNodeId;
     /**
      * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
      * option to specify the property name and whether to return only one node.
@@ -76,16 +86,15 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      */
     getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
-     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
-     * a binary search tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
-     * calculate the lesser sum.
+     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a lesser value
+     * than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-     * binary search tree that have a property value lesser than the given `id`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in a binary
+     * tree that have a lesser value than the specified `beginNode` based on the specified `propertyName`.
      */
-    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    lesserSum(beginNode: N | BinaryTreeNodeId | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
      * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
      * that have a greater value than a given node.
@@ -98,7 +107,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * defaults to 'id'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    allGreaterNodesAdd(node: N | BinaryTreeNodeId | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
      * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
      * recursive or iterative approach.

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

@@ -39,6 +39,19 @@ var BSTNode = /** @class */ (function (_super) {
     function BSTNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function creates a new binary search tree node with the specified id, value, and count.
+     * @param {BinaryTreeNodeId} id - The id parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The "val" parameter represents the value that will be stored in the binary tree node. It is an
+     * optional parameter, meaning it can be omitted when calling the "createNode" function.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary
+     * search tree node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the FAMILY type.
+     */
+    BSTNode.prototype.createNode = function (id, val, count) {
+        return new BSTNode(id, val, count);
+    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
@@ -59,9 +72,18 @@ var BST = /** @class */ (function (_super) {
         }
         return _this;
     }
-    BST.prototype._createNode = function (id, val, count) {
-        var node = val !== null ? new BSTNode(id, val, count) : null;
-        return node;
+    /**
+     * The function creates a new binary search tree node with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`.
+     * @param {N['val'] | null} [val] - The `val` parameter is the value that will be stored in the node. It can be of any
+     * type `N['val']` or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of occurrences
+     * of a particular value in the binary search tree node.
+     * @returns a new instance of the BSTNode class, casted as type N.
+     */
+    BST.prototype.createNode = function (id, val, count) {
+        return new BSTNode(id, val, count);
     };
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
@@ -78,7 +100,7 @@ var BST = /** @class */ (function (_super) {
     BST.prototype.add = function (id, val, count) {
         if (count === void 0) { count = 1; }
         var inserted = null;
-        var newNode = this._createNode(id, val, count);
+        var newNode = this.createNode(id, val, count);
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
@@ -105,7 +127,6 @@ var BST = /** @class */ (function (_super) {
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = types_1.FamilyPosition.LEFT;
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
@@ -125,7 +146,6 @@ var BST = /** @class */ (function (_super) {
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
@@ -179,67 +199,6 @@ var BST = /** @class */ (function (_super) {
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
     };
-    /**
-     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
-     * the deleted node and any nodes that need to be balanced.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
-     * from the binary search tree.
-     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
-     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
-     * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<N>` objects.
-     */
-    BST.prototype.remove = function (id, ignoreCount) {
-        var bstDeletedResult = [];
-        if (!this.root)
-            return bstDeletedResult;
-        var curr = this.get(id);
-        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 (!curr.left) {
-                if (!parent) {
-                    if (curr.right !== undefined)
-                        this._setRoot(curr.right);
-                }
-                else {
-                    switch (curr.familyPosition) {
-                        case types_1.FamilyPosition.LEFT:
-                            parent.left = curr.right;
-                            break;
-                        case types_1.FamilyPosition.RIGHT:
-                            parent.right = curr.right;
-                            break;
-                    }
-                    needBalanced = parent;
-                }
-            }
-            else {
-                var leftSubTreeMax = curr.left ? this.getRightMost(curr.left) : null;
-                if (leftSubTreeMax) {
-                    var parentOfLeftSubTreeMax = leftSubTreeMax.parent;
-                    orgCurrent = curr.swapLocation(leftSubTreeMax);
-                    if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeMax)
-                            parentOfLeftSubTreeMax.right = leftSubTreeMax.left;
-                        else
-                            parentOfLeftSubTreeMax.left = leftSubTreeMax.left;
-                        needBalanced = parentOfLeftSubTreeMax;
-                    }
-                }
-            }
-            this._setSize(this.size - 1);
-            this._setCount(this.count - curr.count);
-        }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
-        return bstDeletedResult;
-    };
     /**
      * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
      * option to specify the property name and whether to return only one node.
@@ -302,20 +261,24 @@ var BST = /** @class */ (function (_super) {
     };
     // --- start additional functions
     /**
-     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
-     * a binary search tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
-     * calculate the lesser sum.
+     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a lesser value
+     * than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-     * binary search tree that have a property value lesser than the given `id`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in a binary
+     * tree that have a lesser value than the specified `beginNode` based on the specified `propertyName`.
      */
-    BST.prototype.lesserSum = function (id, propertyName) {
+    BST.prototype.lesserSum = function (beginNode, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof beginNode === 'number')
+            beginNode = this.get(beginNode, 'id');
+        if (!beginNode)
+            return 0;
         if (!this.root)
             return 0;
+        var id = beginNode.id;
         var getSumByPropertyName = function (cur) {
             var needSum;
             switch (propertyName) {
@@ -404,6 +367,11 @@ var BST = /** @class */ (function (_super) {
     BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof node === 'number')
+            node = this.get(node, 'id');
+        if (!node)
+            return false;
+        var id = node.id;
         if (!this.root)
             return false;
         var _sumByPropertyName = function (cur) {
@@ -421,7 +389,7 @@ var BST = /** @class */ (function (_super) {
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_3 = function (cur) {
-                var compared = _this._compare(cur.id, node.id);
+                var compared = _this._compare(cur.id, id);
                 _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;

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

@@ -1 +1,30 @@
-export {};
+import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../types';
+import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
+import { BST, BSTNode } from './bst';
+export declare class RBTreeNode<T = any, FAMILY extends RBTreeNode<T, FAMILY> = RBTreeNodeNested<T>> extends BSTNode<T, FAMILY> implements IRBTreeNode<T, FAMILY> {
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+    private _color;
+    get color(): RBColor;
+    set color(value: RBColor);
+    /**
+     * The function creates a new RBTreeNode with the given id, value, and count and returns it as a FAMILY object.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T | null} [val] - The "val" parameter represents the value to be stored in the node. It can be of type T
+     * (generic type) or null.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node.
+     * @returns The method is returning a new instance of the RBTreeNode class, casted as a FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+}
+export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
+    constructor(options?: RBTreeOptions);
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    insert(id: number, val?: N | null): void;
+    private leftRotate;
+    private rightRotate;
+    private insertFixup;
+    private deleteFixup;
+    private transplant;
+}

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

@@ -15,19 +15,17 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var binary_tree_1 = require("./binary-tree");
+exports.RBTree = exports.RBTreeNode = void 0;
 var types_1 = require("../types");
-var RBNode = /** @class */ (function (_super) {
-    __extends(RBNode, _super);
-    // override createNode(id: BinaryTreeNodeId, val: T | null, count?: number): RBNode<T> | null {
-    //     return val !== null ? new RBNode<T>(id, val, count) : null;
-    // }
-    function RBNode(id, val, count) {
+var bst_1 = require("./bst");
+var RBTreeNode = /** @class */ (function (_super) {
+    __extends(RBTreeNode, _super);
+    function RBTreeNode(id, val, count) {
         var _this = _super.call(this, id, val, count) || this;
         _this._color = types_1.RBColor.RED;
         return _this;
     }
-    Object.defineProperty(RBNode.prototype, "color", {
+    Object.defineProperty(RBTreeNode.prototype, "color", {
         get: function () {
             return this._color;
         },
@@ -37,16 +35,30 @@ var RBNode = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    return RBNode;
-}(binary_tree_1.BinaryTreeNode));
+    /**
+     * The function creates a new RBTreeNode with the given id, value, and count and returns it as a FAMILY object.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T | null} [val] - The "val" parameter represents the value to be stored in the node. It can be of type T
+     * (generic type) or null.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node.
+     * @returns The method is returning a new instance of the RBTreeNode class, casted as a FAMILY type.
+     */
+    RBTreeNode.prototype.createNode = function (id, val, count) {
+        return new RBTreeNode(id, val, count);
+    };
+    return RBTreeNode;
+}(bst_1.BSTNode));
+exports.RBTreeNode = RBTreeNode;
 var RBTree = /** @class */ (function (_super) {
     __extends(RBTree, _super);
     function RBTree(options) {
         return _super.call(this, options) || this;
     }
-    // override _createNode(id: BinaryTreeNodeId, val: N | null, count?: number): RBNode<N> | null {
-    //     return val !== null ? new RBNode<N>(id, val, count) : null;
-    // }
+    RBTree.prototype.createNode = function (id, val, count) {
+        return new RBTreeNode(id, val, count);
+    };
     // private override _root: BinaryTreeNode<N> | null = null;
     //
     // override get root(): BinaryTreeNode<N> | null {
@@ -65,4 +77,5 @@ var RBTree = /** @class */ (function (_super) {
     RBTree.prototype.transplant = function (u, v) {
     };
     return RBTree;
-}(binary_tree_1.BinaryTree));
+}(bst_1.BST));
+exports.RBTree = RBTree;

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

@@ -5,15 +5,26 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, RecursiveTreeMultiSetNode, TreeMultiSetOptions } from '../types';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+import type { BinaryTreeNodeId, TreeMultiSetNodeNested, TreeMultiSetOptions } from '../types';
+import { ITreeMultiSet, ITreeMultiSetNode } from '../interfaces';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export declare class TreeMultiSetNode<T = any, FAMILY extends TreeMultiSetNode<T, FAMILY> = TreeMultiSetNodeNested<T>> extends AVLTreeNode<T, FAMILY> implements ITreeMultiSetNode<T, FAMILY> {
+    /**
+     * The function creates a new node in a binary tree with an optional value and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
+     * meaning it can be omitted when calling the `createNode` method.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 /**
- * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiSet and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBinaryTree<N> {
+export declare class TreeMultiSet<N extends TreeMultiSetNode<N['val'], N> = TreeMultiSetNode> extends AVLTree<N> implements ITreeMultiSet<N> {
     constructor(options?: TreeMultiSetOptions);
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -24,5 +35,5 @@ export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<numbe
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    _createNode(id: BinaryTreeNodeId, val: N['val'], count?: number): N;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -27,29 +27,35 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = exports.TreeMultiSetNode = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-var bst_1 = require("./bst");
+var avl_tree_1 = require("./avl-tree");
 var TreeMultiSetNode = /** @class */ (function (_super) {
     __extends(TreeMultiSetNode, _super);
     function TreeMultiSetNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function creates a new node in a binary tree with an optional value and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
+     * meaning it can be omitted when calling the `createNode` method.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
+     */
+    TreeMultiSetNode.prototype.createNode = function (id, val, count) {
+        return new TreeMultiSetNode(id, val, count);
+    };
     return TreeMultiSetNode;
-}(bst_1.BSTNode));
+}(avl_tree_1.AVLTreeNode));
 exports.TreeMultiSetNode = TreeMultiSetNode;
 /**
- * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiSet and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 var TreeMultiSet = /** @class */ (function (_super) {
     __extends(TreeMultiSet, _super);
     function TreeMultiSet(options) {
-        return _super.call(this, __assign(__assign({}, options), { isDuplicatedVal: true })) || this;
+        return _super.call(this, __assign(__assign({}, options), { isMergeDuplicatedVal: true })) || this;
     }
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -60,10 +66,9 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    TreeMultiSet.prototype._createNode = function (id, val, count) {
-        var node = new TreeMultiSetNode(id, val, count);
-        return node;
+    TreeMultiSet.prototype.createNode = function (id, val, count) {
+        return new TreeMultiSetNode(id, val, count);
     };
     return TreeMultiSet;
-}(bst_1.BST));
+}(avl_tree_1.AVLTree));
 exports.TreeMultiSet = TreeMultiSet;