data-structure-typed 1.18.0 → 1.18.5

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

@@ -151,24 +151,29 @@ var BinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    BinaryTreeNode.prototype._createNode = function (id, val, count) {
+        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    };
     BinaryTreeNode.prototype.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = new BinaryTreeNode(swapNode.id, val);
-        tempNode.val = val;
-        tempNode.count = count;
-        tempNode.height = height;
-        swapNode.id = this.id;
-        swapNode.val = this.val;
-        swapNode.count = this.count;
-        swapNode.height = this.height;
-        this.id = tempNode.id;
-        this.val = tempNode.val;
-        this.count = tempNode.count;
-        this.height = tempNode.height;
+        var tempNode = this._createNode(swapNode.id, val);
+        if (tempNode instanceof BinaryTreeNode) {
+            tempNode.val = val;
+            tempNode.count = count;
+            tempNode.height = height;
+            swapNode.id = this.id;
+            swapNode.val = this.val;
+            swapNode.count = this.count;
+            swapNode.height = this.height;
+            this.id = tempNode.id;
+            this.val = tempNode.val;
+            this.count = tempNode.count;
+            this.height = tempNode.height;
+        }
         return swapNode;
     };
     BinaryTreeNode.prototype.clone = function () {
-        return new BinaryTreeNode(this.id, this.val, this.count);
+        return this._createNode(this.id, this.val, this.count);
     };
     return BinaryTreeNode;
 }());
@@ -284,19 +289,19 @@ var BinaryTree = /** @class */ (function () {
         configurable: true
     });
     /**
-     * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
-     * null.
+     * The function creates a new binary tree node with the given id, value, and count if the value is not null, otherwise
+     * it returns null.
      * @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 | null} val - The `val` parameter represents the value to be stored in the binary tree node. It can be of
-     * any type `T` or `null`.
-     * @param {number} [count] - The count parameter is an optional parameter that represents the number of occurrences of
-     * the value in the binary tree node. It is of type number.
-     * @returns The function `createNode` returns a `BinaryTreeNode<T>` object if the `val` parameter is not null.
-     * Otherwise, it returns null.
+     * `BinaryTreeNodeId`.
+     * @param {N | null} val - The `val` parameter represents the value of the node. It can be of type `N` (generic type)
+     * or `null`.
+     * @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 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) {
-        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    BinaryTree.prototype._createNode = function (id, val, count) {
+        var node = new BinaryTreeNode(id, val, count);
+        return node;
     };
     /**
      * The clear function resets the state of an object by setting its properties to their initial values.
@@ -319,10 +324,10 @@ var BinaryTree = /** @class */ (function () {
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
-     * @param {T} val - The value to be inserted into the binary tree.
+     * @param {N} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `N` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
     BinaryTree.prototype.add = function (id, val, count) {
@@ -347,7 +352,7 @@ var BinaryTree = /** @class */ (function () {
             return;
         };
         var inserted;
-        var needInsert = val !== null ? new BinaryTreeNode(id, val, count) : null;
+        var needInsert = val !== null ? this._createNode(id, val, count) : null;
         var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
@@ -363,7 +368,7 @@ var BinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this._setRoot(val !== null ? new BinaryTreeNode(id, val, count) : null);
+            this._setRoot(val !== null ? this._createNode(id, val, count) : null);
             if (needInsert !== null) {
                 this._setSize(1);
                 this._setCount(count);
@@ -374,7 +379,7 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * @param {N | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
      * `null`. It represents the node that needs to be inserted into the binary tree.
      * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
      * will be inserted as a child.
@@ -391,7 +396,7 @@ var BinaryTree = /** @class */ (function () {
                 parent.left = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_a = this.count + (newNode === null || newNode === void 0 ? void 0 : newNode.count)) !== null && _a !== void 0 ? _a : 0);
+                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 0);
                 }
                 return parent.left;
             }
@@ -403,7 +408,7 @@ var BinaryTree = /** @class */ (function () {
                 parent.right = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_b = this.count + (newNode === null || newNode === void 0 ? void 0 : newNode.count)) !== null && _b !== void 0 ? _b : 0);
+                    this._setCount((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
                 }
                 return parent.right;
             }
@@ -418,9 +423,9 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
-     * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
-     * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
+     * array of `N` objects.
+     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
     BinaryTree.prototype.addMany = function (data) {
         var e_1, _a, e_2, _b;
@@ -490,8 +495,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `fill` function clears the current data and inserts new data, returning a boolean indicating if the insertion
      * was successful.
-     * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
-     * array of `BinaryTreeNode<T>` objects.
+     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
+     * array of `N` objects.
      * @returns The method is returning a boolean value.
      */
     BinaryTree.prototype.fill = function (data) {
@@ -546,7 +551,7 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function calculates the depth of a binary tree node by traversing its parent nodes.
-     * @param node - BinaryTreeNode<T> - This is the node for which we want to calculate the depth. It is a generic type,
+     * @param node - N - This is the node for which we want to calculate the depth. It is a generic type,
      * meaning it can represent any type of data that we want to store in the node.
      * @returns The depth of the given binary tree node.
      */
@@ -561,8 +566,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the height of the binary tree.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `N | null`. It represents the starting node from which to calculate the height of the binary tree.
      * If no value is provided for `beginRoot`, the function will use the `root` property of the class instance as
      * @returns the height of the binary tree.
      */
@@ -612,8 +617,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
      * approach.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
-     * `BinaryTreeNode<T> | null`. It represents the starting node from which to calculate the minimum height of the binary
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type
+     * `N | null`. It represents the starting node from which to calculate the minimum height of the binary
      * tree. If no value is provided for `beginRoot`, the function will use the root node of the binary tree.
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
@@ -664,8 +669,8 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The function checks if a binary tree is balanced by comparing the minimum height and the maximum height of the tree.
-     * @param {BinaryTreeNode<T> | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
-     * of type `BinaryTreeNode<T> | null`, which means it can either be a `BinaryTreeNode` object or `null`.
+     * @param {N | null} [beginRoot] - The `beginRoot` parameter is the root node of a binary tree. It is
+     * of type `N | null`, which means it can either be a `BinaryTreeNode` object or `null`.
      * @returns The method is returning a boolean value.
      */
     BinaryTree.prototype.isBalanced = function (beginRoot) {
@@ -674,14 +679,14 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function `getNodes` returns an array of binary tree nodes that match a given property value, with options for
      * searching recursively or iteratively.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use when searching for nodes. If not provided, it defaults to 'id'.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the `nodeProperty` or `propertyName` criteria. If `onlyOne` is set to `true`, the
      * function will stop traversing the tree and return the first matching node. If `
-     * @returns The function `getNodes` returns an array of `BinaryTreeNode<T> | null | undefined` objects.
+     * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
      */
     BinaryTree.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -717,8 +722,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function checks if a binary tree node has a specific property or if any node in the tree has a specific
      * property.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of a binary tree node that you want to check.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property of a binary tree node that you want to check.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the name of the property to check for in the nodes.
      * @returns a boolean value.
@@ -729,8 +734,8 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function returns the first binary tree node that matches the given property name and value, or null if no match
      * is found.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property of the binary tree node that you want to search for.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the binary tree node to search for. If not provided, it defaults to `'id'`.
      * @returns a BinaryTreeNode object or null.
@@ -744,7 +749,7 @@ var BinaryTree = /** @class */ (function () {
      * The function getPathToRoot returns an array of BinaryTreeNode objects representing the path from a given node to the
      * root of a binary tree.
      * @param node - The `node` parameter is a BinaryTreeNode object.
-     * @returns The function `getPathToRoot` returns an array of `BinaryTreeNode<T>` objects, representing the path from
+     * @returns The function `getPathToRoot` returns an array of `N` objects, representing the path from
      * the given `node` to the root of the binary tree.
      */
     BinaryTree.prototype.getPathToRoot = function (node) {
@@ -759,7 +764,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getLeftMost` function returns the leftmost node in a binary tree, either recursively or iteratively using tail
      * recursion optimization.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
      * | null`. It represents the starting node from which to find the leftmost node in a binary tree. If no node is
      * provided, the function will use the root node of the binary tree.
      * @returns The `getLeftMost` function returns the leftmost node in a binary tree.
@@ -789,7 +794,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or iteratively using
      * tail recursion optimization.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
      * | null`. It represents the starting node from which to find the rightmost node in a binary tree. If no node is
      * provided, the function will use the root node of the binary tree.
      * @returns The `getRightMost` function returns the rightmost node in a binary tree.
@@ -818,7 +823,7 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The `isBST` function checks if a binary tree is a binary search tree.
-     * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>
+     * @param {N | null} [node] - The `node` parameter is an optional parameter of type `N
      * | null`. It represents the root node of the binary search tree (BST) that we want to check for validity. If no node
      * is provided, the function will default to using the root node of the BST instance that
      * @returns The `isBST` function returns a boolean value. It returns `true` if the binary tree is a valid binary search
@@ -858,7 +863,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
      * traversal.
-     * @param {BinaryTreeNode<T> | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
+     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter is the root node of a binary
      * tree.
      * @returns The function `getSubTreeSizeAndCount` returns an array `[number, number]`. The first element of the array
      * represents the size of the subtree, and the second element represents the count of the nodes in the subtree.
@@ -996,7 +1001,7 @@ var BinaryTree = /** @class */ (function () {
      * represents either a node or a property name. If a node is provided, the breadth-first search algorithm will be
      * performed starting from that node. If a property name is provided, the breadth-first search algorithm will be
      * performed starting from the root node
-     * @returns an object of type `ResultsByProperty<T>`.
+     * @returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1024,7 +1029,7 @@ var BinaryTree = /** @class */ (function () {
      * either the name of a property in the `BinaryTreeNode` object or the value of the `id` property in the
      * `BinaryTreeNode` object. This parameter is used to accumulate the results based on the specified property name. If
      * no value
-     * @returns an object of type `ResultsByProperty<T>`.
+     * @returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1111,14 +1116,14 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The `levelIterative` function performs a level-order traversal on a binary tree and returns the values of the nodes
      * in an array, based on a specified property name.
-     * @param {BinaryTreeNode<T> | null} node - The `node` parameter is a BinaryTreeNode object representing the starting
+     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object representing the starting
      * node for the level order traversal. It can be null if no specific node is provided, in which case the root node of
      * the tree is used as the starting node.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
      * can be either a `BinaryTreeNode` property name or the string `'id'`. If a property name is provided, the function
      * will accumulate results based on that property. If no property name is provided, the function will default to
      * accumulating results
-     * @returns The function `levelIterative` returns an object of type `ResultsByProperty<T>`.
+     * @returns The function `levelIterative` returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1143,12 +1148,12 @@ var BinaryTree = /** @class */ (function () {
     };
     /**
      * The `listLevels` function collects nodes from a binary tree by a specified property and organizes them into levels.
-     * @param {BinaryTreeNode<T> | null} node - The `node` parameter is a BinaryTreeNode object or null. It represents the
+     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object or null. It represents the
      * root node of a binary tree. If it is null, the function will use the root node of the current binary tree instance.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
      * specifies the property of the `BinaryTreeNode` object to collect at each level. It can be one of the following
      * values:
-     * @returns The function `listLevels` returns a 2D array of `ResultByProperty<T>` objects.
+     * @returns The function `listLevels` returns a 2D array of `ResultByProperty<N>` objects.
      */
     BinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1232,7 +1237,7 @@ var BinaryTree = /** @class */ (function () {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is used to specify the
      * property of the nodes that you want to retrieve in the results. It can be either the node itself or the name of the
      * property. If not provided, it defaults to `'id'`.
-     * @returns The function `morris` returns an object of type `ResultsByProperty<T>`.
+     * @returns The function `morris` returns an object of type `ResultsByProperty<N>`.
      */
     BinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1375,9 +1380,9 @@ var BinaryTree = /** @class */ (function () {
      * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
      * a result array.
      * @param cur - The current binary tree node that is being checked.
-     * @param {(BinaryTreeNode<T> | null | undefined)[]} result - An array that stores the matching nodes found during the
+     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes found during the
      * traversal.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter is the value that we are searching for in
      * the binary tree nodes. It can be either the `id`, `count`, or `val` property of the node.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the `BinaryTreeNode` object that you want to compare with the `nodeProperty` value. It can
@@ -1418,7 +1423,7 @@ var BinaryTree = /** @class */ (function () {
     /**
      * The function `_accumulatedByPropertyName` pushes a property value of a binary tree node into an array based on the
      * provided property name or a default property name.
-     * @param node - The `node` parameter is of type `BinaryTreeNode<T>`, which represents a node in a binary tree.
+     * @param node - The `node` parameter is of type `N`, which represents a node in a binary tree.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
      * can be either a string representing a property name or a reference to a node object. If it is a string, it specifies
      * the property name of the node that should be accumulated. If it is a node object, it specifies the node itself

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

@@ -5,17 +5,17 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult } from '../types';
+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> extends BinaryTreeNode<T> {
-    clone(): BSTNode<T>;
+export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
 }
-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:
@@ -24,30 +24,30 @@ export declare class BST<T> extends BinaryTree<T> {
         comparator?: BSTComparator;
         loopType?: LoopType;
     });
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    _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 +65,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): BSTDeletedResult<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 +96,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 +105,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

@@ -44,9 +44,6 @@ var BSTNode = /** @class */ (function (_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 +64,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);
@@ -157,12 +155,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;
@@ -194,7 +192,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 = [];
@@ -250,15 +248,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;
@@ -399,7 +397,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.

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

@@ -1,2 +1 @@
-export declare class RBTree {
-}
+export {};