data-structure-typed 1.18.5 → 1.18.7

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

@@ -5,26 +5,40 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult, RecursiveBSTNode } from '../types';
-import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare enum CP {
-    lt = -1,
-    eq = 0,
-    gt = 1
-}
-export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, RecursiveBSTNode } from '../types';
+import { BinaryTreeDeletedResult, BSTOptions, CP } from '../types';
+import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import { IBST, IBSTNode } from '../interfaces';
+export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<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<number>> 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?: {
-        comparator?: BSTComparator;
-        loopType?: LoopType;
-    });
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    constructor(options?: BSTOptions);
+    /**
+     * 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.
@@ -56,7 +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;
+    lastKey(): BinaryTreeNodeId;
     /**
      * 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.
@@ -67,7 +81,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * 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): BSTDeletedResult<N>[];
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * 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.

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

@@ -31,19 +31,27 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BST = exports.BSTNode = exports.CP = void 0;
+exports.BST = exports.BSTNode = void 0;
+var types_1 = require("../types");
 var binary_tree_1 = require("./binary-tree");
-var CP;
-(function (CP) {
-    CP[CP["lt"] = -1] = "lt";
-    CP[CP["eq"] = 0] = "eq";
-    CP[CP["gt"] = 1] = "gt";
-})(CP || (exports.CP = CP = {}));
 var BSTNode = /** @class */ (function (_super) {
     __extends(BSTNode, _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 === undefined ? id : val), count);
+    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
@@ -64,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 === undefined ? 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
@@ -83,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);
@@ -95,7 +112,7 @@ var BST = /** @class */ (function (_super) {
             var traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, id) === CP.eq) {
+                    if (this._compare(cur.id, id) === types_1.CP.eq) {
                         if (newNode) {
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
@@ -105,12 +122,12 @@ var BST = /** @class */ (function (_super) {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, id) === CP.gt) {
+                    else if (this._compare(cur.id, id) === types_1.CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = binary_tree_1.FamilyPosition.left;
+                                newNode.familyPosition = types_1.FamilyPosition.LEFT;
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
@@ -125,12 +142,12 @@ var BST = /** @class */ (function (_super) {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, id) === CP.lt) {
+                    else if (this._compare(cur.id, id) === types_1.CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = binary_tree_1.FamilyPosition.right;
+                                newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
@@ -177,9 +194,9 @@ var BST = /** @class */ (function (_super) {
      */
     BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
-        if (this._compare(0, 1) === CP.lt)
+        if (this._compare(0, 1) === types_1.CP.lt)
             return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
-        else if (this._compare(0, 1) === CP.gt)
+        else if (this._compare(0, 1) === types_1.CP.gt)
             return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
@@ -215,10 +232,10 @@ var BST = /** @class */ (function (_super) {
                 }
                 else {
                     switch (curr.familyPosition) {
-                        case binary_tree_1.FamilyPosition.left:
+                        case types_1.FamilyPosition.LEFT:
                             parent.left = curr.right;
                             break;
-                        case binary_tree_1.FamilyPosition.right:
+                        case types_1.FamilyPosition.RIGHT:
                             parent.right = curr.right;
                             break;
                     }
@@ -264,16 +281,16 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return [];
         var result = [];
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_1 = function (cur) {
                 if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
                 if (propertyName === 'id') {
-                    if (_this._compare(cur.id, nodeProperty) === CP.gt)
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.gt)
                         cur.left && _traverse_1(cur.left);
-                    if (_this._compare(cur.id, nodeProperty) === CP.lt)
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.lt)
                         cur.right && _traverse_1(cur.right);
                 }
                 else {
@@ -291,9 +308,9 @@ var BST = /** @class */ (function (_super) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
                     if (propertyName === 'id') {
-                        if (this._compare(cur.id, nodeProperty) === CP.gt)
+                        if (this._compare(cur.id, nodeProperty) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.id, nodeProperty) === CP.lt)
+                        if (this._compare(cur.id, nodeProperty) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -337,15 +354,15 @@ var BST = /** @class */ (function (_super) {
             return needSum;
         };
         var sum = 0;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_2 = function (cur) {
                 var compared = _this._compare(cur.id, id);
-                if (compared === CP.eq) {
+                if (compared === types_1.CP.eq) {
                     if (cur.right)
                         sum += _this.subTreeSum(cur.right, propertyName);
                     return;
                 }
-                else if (compared === CP.lt) {
+                else if (compared === types_1.CP.lt) {
                     if (cur.left)
                         sum += _this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
@@ -369,12 +386,12 @@ var BST = /** @class */ (function (_super) {
                 var cur = queue.shift();
                 if (cur) {
                     var compared = this._compare(cur.id, id);
-                    if (compared === CP.eq) {
+                    if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
                         return sum;
                     }
-                    else if (compared === CP.lt) { // todo maybe a bug
+                    else if (compared === types_1.CP.lt) { // todo maybe a bug
                         if (cur.left)
                             sum += this.subTreeSum(cur.left, propertyName);
                         sum += getSumByPropertyName(cur);
@@ -424,15 +441,15 @@ var BST = /** @class */ (function (_super) {
                     break;
             }
         };
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_3 = function (cur) {
                 var compared = _this._compare(cur.id, node.id);
                 _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && compared === CP.gt)
+                if (cur.left && compared === types_1.CP.gt)
                     _traverse_3(cur.left);
-                else if (cur.right && compared === CP.gt)
+                else if (cur.right && compared === types_1.CP.gt)
                     _traverse_3(cur.right);
             };
             _traverse_3(this.root);
@@ -445,9 +462,9 @@ var BST = /** @class */ (function (_super) {
                 if (cur) {
                     var compared = this._compare(cur.id, node.id);
                     _sumByPropertyName(cur);
-                    if (cur.left && compared === CP.gt)
+                    if (cur.left && compared === types_1.CP.gt)
                         queue.push(cur.left);
-                    else if (cur.right && compared === CP.gt)
+                    else if (cur.right && compared === types_1.CP.gt)
                         queue.push(cur.right);
                 }
             }
@@ -465,7 +482,7 @@ var BST = /** @class */ (function (_super) {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
@@ -506,7 +523,7 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return true;
         var balanced = true;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _height_1 = function (cur) {
                 if (!cur)
                     return 0;
@@ -558,11 +575,11 @@ var BST = /** @class */ (function (_super) {
     BST.prototype._compare = function (a, b) {
         var compared = this._comparator(a, b);
         if (compared > 0)
-            return CP.gt;
+            return types_1.CP.gt;
         else if (compared < 0)
-            return CP.lt;
+            return types_1.CP.lt;
         else
-            return CP.eq;
+            return types_1.CP.eq;
     };
     return BST;
 }(binary_tree_1.BinaryTree));

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

@@ -1,3 +1,4 @@
+export * from './abstract-binary-tree';
 export * from './binary-tree';
 export * from './bst';
 export * from './binary-indexed-tree';

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

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract-binary-tree"), exports);
 __exportStar(require("./binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./binary-indexed-tree"), exports);

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

@@ -1 +1,30 @@
-export {};
+import { BinaryTreeNodeId, RBColor, RBTreeOptions } from '../types';
+import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
+import { BST, BSTNode } from './bst';
+export declare class RBTreeNode<T, FAMILY extends RBTreeNode<T, FAMILY>> extends BSTNode<T, FAMILY> implements IRBTreeNode<T, FAMILY> {
+    constructor(id: number, 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 | null, count?: number): FAMILY;
+}
+export declare class RBTree<N extends RBTreeNode<N['val'], N>> 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,23 +15,17 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var binary_tree_1 = require("./binary-tree");
-var RBColor;
-(function (RBColor) {
-    RBColor[RBColor["Red"] = 0] = "Red";
-    RBColor[RBColor["Black"] = 1] = "Black";
-})(RBColor || (RBColor = {}));
-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) {
+exports.RBTree = exports.RBTreeNode = void 0;
+var types_1 = require("../types");
+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 = RBColor.Red;
+        _this._color = types_1.RBColor.RED;
         return _this;
     }
-    Object.defineProperty(RBNode.prototype, "color", {
+    Object.defineProperty(RBTreeNode.prototype, "color", {
         get: function () {
             return this._color;
         },
@@ -41,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 {
@@ -69,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

@@ -6,9 +6,26 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
-import { IBinaryTree } from '../interfaces';
-export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBinaryTree<N> {
+import type { BinaryTreeNodeId, RecursiveTreeMultiSetNode, TreeMultiSetOptions } from '../types';
+import { IBST, IBSTNode } from '../interfaces';
+export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBSTNode<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.
+ */
+export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBST<N> {
+    constructor(options?: TreeMultiSetOptions);
     /**
      * The function creates a new BSTNode with the given id, value, and count.
      * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
@@ -18,26 +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;
-    /**
-     * The function overrides the add method of the BinarySearchTree class in TypeScript.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `N` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
-     */
-    add(id: BinaryTreeNodeId, val: N | null, count?: number): N | null;
-    /**
-     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
-     * method.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
-     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
-     * set to `true`, the left sum of all nodes will be recalculated. If it
-     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
-     */
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<N>[];
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -14,8 +14,19 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultiSet = void 0;
+exports.TreeMultiSet = exports.TreeMultiSetNode = void 0;
 /**
  * data-structure-typed
  *
@@ -24,10 +35,34 @@ exports.TreeMultiSet = void 0;
  * @license MIT License
  */
 var bst_1 = require("./bst");
+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 === undefined ? id : val), count);
+    };
+    return TreeMultiSetNode;
+}(bst_1.BSTNode));
+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.
+ */
 var TreeMultiSet = /** @class */ (function (_super) {
     __extends(TreeMultiSet, _super);
-    function TreeMultiSet() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function TreeMultiSet(options) {
+        return _super.call(this, __assign(__assign({}, options), { isDuplicatedVal: true })) || this;
     }
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -38,34 +73,8 @@ 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 bst_1.BSTNode(id, val, count);
-        return node;
-    };
-    /**
-     * The function overrides the add method of the BinarySearchTree class in TypeScript.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `N` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
-     */
-    TreeMultiSet.prototype.add = function (id, val, count) {
-        return _super.prototype.add.call(this, id, val, count);
-    };
-    /**
-     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
-     * method.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
-     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
-     * set to `true`, the left sum of all nodes will be recalculated. If it
-     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
-     */
-    TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
-        return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
+    TreeMultiSet.prototype.createNode = function (id, val, count) {
+        return new TreeMultiSetNode(id, val === undefined ? id : val, count);
     };
     return TreeMultiSet;
 }(bst_1.BST));