data-structure-typed 1.18.0 → 1.18.6

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

@@ -5,49 +5,42 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult } from '../types';
-import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
-export declare enum CP {
-    lt = -1,
-    eq = 0,
-    gt = 1
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, RecursiveBSTNode } from '../types';
+import { BinaryTreeDeletedResult, 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> {
 }
-export declare class BSTNode<T> extends BinaryTreeNode<T> {
-    clone(): BSTNode<T>;
-}
-export declare class BST<T> extends BinaryTree<T> {
+export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BinaryTree<N> implements IBinaryTree<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: T | null, count?: number): BSTNode<T> | null;
+    constructor(options?: BSTOptions);
+    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * 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.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
      * determine the position of the node in the binary search tree.
-     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
-     * be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `N` (the generic type) or `null`.
      * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
      * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
      * inserted once.
-     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
+     * @returns The method `add` returns a `N` object or `null`.
      */
-    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    add(id: BinaryTreeNodeId, val: N['val'] | null, 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 | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the value of the property that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
      * `'id'`.
-     * @returns The method is returning a BSTNode<T> object or null.
+     * @returns The method is returning a N object or null.
      */
-    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     /**
      * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
      * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
@@ -65,23 +58,23 @@ export declare class BST<T> extends BinaryTree<T> {
      * @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<T>` objects.
+     * @returns an array of `BSTDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[];
+    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.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property value that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
      * `'id'`.
      * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
      * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
      * to false or not provided, the function will return all nodes that match the given nodeProperty.
-     * @returns an array of BSTNode<T> objects.
+     * @returns an array of N objects.
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): BSTNode<T>[];
+    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.
@@ -96,7 +89,7 @@ export declare class BST<T> extends BinaryTree<T> {
     /**
      * 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.
-     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * @param node - The `node` parameter is of type `N`, which represents a node in a binary search tree. It
      * contains properties such as `id` and `count`.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each node should be increased.
@@ -105,7 +98,7 @@ export declare class BST<T> extends BinaryTree<T> {
      * defaults to 'id'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    allGreaterNodesAdd(node: N, 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

@@ -31,22 +31,14 @@ 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;
     }
-    BSTNode.prototype.clone = function () {
-        return new BSTNode(this.id, this.val, this.count);
-    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
@@ -67,25 +59,26 @@ var BST = /** @class */ (function (_super) {
         }
         return _this;
     }
-    BST.prototype.createNode = function (id, val, count) {
-        return val !== null ? new BSTNode(id, val, count) : null;
+    BST.prototype._createNode = function (id, val, count) {
+        var node = val !== null ? new BSTNode(id, val, count) : null;
+        return node;
     };
     /**
      * 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.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
      * determine the position of the node in the binary search tree.
-     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
-     * be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `N` (the generic type) or `null`.
      * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
      * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
      * inserted once.
-     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
+     * @returns The method `add` returns a `N` object or `null`.
      */
     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);
@@ -97,7 +90,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);
@@ -107,12 +100,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;
@@ -127,12 +120,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;
@@ -157,12 +150,12 @@ var BST = /** @class */ (function (_super) {
     };
     /**
      * The `get` function returns the first node in a binary search tree that matches the given property value or name.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the value of the property that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
      * `'id'`.
-     * @returns The method is returning a BSTNode<T> object or null.
+     * @returns The method is returning a N object or null.
      */
     BST.prototype.get = function (nodeProperty, propertyName) {
         var _a;
@@ -179,9 +172,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;
@@ -194,7 +187,7 @@ var BST = /** @class */ (function (_super) {
      * @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<T>` objects.
+     * @returns an array of `BSTDeletedResult<N>` objects.
      */
     BST.prototype.remove = function (id, ignoreCount) {
         var bstDeletedResult = [];
@@ -217,10 +210,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;
                     }
@@ -250,15 +243,15 @@ var BST = /** @class */ (function (_super) {
     /**
      * 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.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property value that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
      * `'id'`.
      * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
      * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
      * to false or not provided, the function will return all nodes that match the given nodeProperty.
-     * @returns an array of BSTNode<T> objects.
+     * @returns an array of N objects.
      */
     BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -266,16 +259,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 {
@@ -293,9 +286,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 {
@@ -339,15 +332,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);
@@ -371,12 +364,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);
@@ -399,7 +392,7 @@ var BST = /** @class */ (function (_super) {
     /**
      * 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.
-     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * @param node - The `node` parameter is of type `N`, which represents a node in a binary search tree. It
      * contains properties such as `id` and `count`.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each node should be increased.
@@ -426,15 +419,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);
@@ -447,9 +440,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);
                 }
             }
@@ -467,7 +460,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;
@@ -508,7 +501,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;
@@ -560,11 +553,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,2 +1 @@
-export declare class RBTree {
-}
+export {};

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

@@ -1,9 +1,68 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTree = void 0;
-var RBTree = /** @class */ (function () {
-    function RBTree() {
+var binary_tree_1 = require("./binary-tree");
+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 _this = _super.call(this, id, val, count) || this;
+        _this._color = types_1.RBColor.RED;
+        return _this;
     }
+    Object.defineProperty(RBNode.prototype, "color", {
+        get: function () {
+            return this._color;
+        },
+        set: function (value) {
+            this._color = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RBNode;
+}(binary_tree_1.BinaryTreeNode));
+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;
+    // }
+    // private override _root: BinaryTreeNode<N> | null = null;
+    //
+    // override get root(): BinaryTreeNode<N> | null {
+    //     return this._root;
+    // }
+    RBTree.prototype.insert = function (id, val) {
+    };
+    RBTree.prototype.leftRotate = function (node) {
+    };
+    RBTree.prototype.rightRotate = function (node) {
+    };
+    RBTree.prototype.insertFixup = function (node) {
+    };
+    RBTree.prototype.deleteFixup = function (node) {
+    };
+    RBTree.prototype.transplant = function (u, v) {
+    };
     return RBTree;
-}());
-exports.RBTree = RBTree;
+}(binary_tree_1.BinaryTree));

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

@@ -6,37 +6,23 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
-export declare class TreeMultiSet<T> extends BST<T> {
+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> {
+}
+/**
+ * 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 IBinaryTree<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
      * distinguish one node from another in the tree.
-     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * 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: T, count?: number): BSTNode<T>;
-    /**
-     * 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 {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `T` (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<T>` object or `null`.
-     */
-    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | 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<T>[];
+    _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,47 +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;
+    }
+    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.
      * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * 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) {
-        return new bst_1.BSTNode(id, val, count);
-    };
-    /**
-     * 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 {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `T` (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<T>` 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) {
+        var node = new TreeMultiSetNode(id, val, count);
+        return node;
     };
     return TreeMultiSet;
 }(bst_1.BST));