data-structure-typed 1.18.6 → 1.18.7

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

@@ -5,17 +5,26 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AbstractRecursiveBinaryTreeNode, AbstractResultsByProperty, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../types';
+import type { AbstractBinaryTreeNodeProperties, AbstractRecursiveBinaryTreeNode, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName } from '../types';
 import { AbstractBinaryTreeOptions, FamilyPosition, LoopType } from '../types';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare abstract class AbstractBinaryTreeNode<T, FAMILY extends AbstractBinaryTreeNode<T, FAMILY> = AbstractRecursiveBinaryTreeNode<T>> implements IBinaryTreeNode<T, FAMILY> {
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
+import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from '../interfaces';
+export declare abstract class AbstractBinaryTreeNode<T = number, FAMILY extends AbstractBinaryTreeNode<T, FAMILY> = AbstractRecursiveBinaryTreeNode<T>> implements IAbstractBinaryTreeNode<T, FAMILY> {
+    /**
+     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * for the binary tree node.
+     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of times the
+     * value `val` appears in the binary tree node. If the `count` parameter is not provided, it defaults to 1.
+     */
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
     private _id;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
     private _val;
-    get val(): T;
-    set val(v: T);
+    get val(): T | undefined;
+    set val(value: T | undefined);
     private _left?;
     get left(): FAMILY | null | undefined;
     set left(v: FAMILY | null | undefined);
@@ -34,11 +43,21 @@ export declare abstract class AbstractBinaryTreeNode<T, FAMILY extends AbstractB
     private _height;
     get height(): number;
     set height(v: number);
-    abstract _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
+    abstract createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+    /**
+     * The function swaps the location of two nodes in a binary tree.
+     * @param {FAMILY} swapNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
+     * @returns the `swapNode` object after swapping its properties with the properties of `this` object.
+     */
     swapLocation(swapNode: FAMILY): FAMILY;
+    /**
+     * The `clone` function returns a new instance of the `FAMILY` class with the same `id`, `val`, and `count` properties.
+     * @returns The `clone()` method is returning a new instance of the `FAMILY` class with the same `id`, `val`, and
+     * `count` values as the current instance.
+     */
     clone(): FAMILY | null;
 }
-export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N> = AbstractBinaryTreeNode<number>> implements IBinaryTree<N> {
+export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N> = AbstractBinaryTreeNode<number>> implements IAbstractBinaryTree<N> {
     /**
      * The protected constructor initializes the options for an abstract binary tree.
      * @param {AbstractBinaryTreeOptions} [options] - An optional object that contains configuration options for the binary
@@ -69,7 +88,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get size(): number;
     private _count;
     get count(): number;
-    abstract _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    abstract createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * The clear function resets the state of an object by setting its properties to their initial values.
      */
@@ -92,12 +111,13 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      */
     add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @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.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
+     * either a node object (`N`) or `null`.
+     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
+     * child.
+     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
+     * `undefined` in certain cases.
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
@@ -172,7 +192,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * function will stop traversing the tree and return the first matching node. If `
      * @returns The function `getNodes` returns an array of `N | null | undefined` objects.
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): (N | null | undefined)[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
      * The function checks if a binary tree node has a specific property or if any node in the tree has a specific
      * property.
@@ -206,12 +226,16 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     getRightMost(): N | null;
     getRightMost(node: N): N;
     /**
-     * The `isBST` function checks if a binary tree is a binary search tree.
-     * @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
-     * tree, and `false` otherwise.
+     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @returns a boolean value.
+     */
+    isBSTByRooted(node: N | null): boolean;
+    /**
+     * The function checks if a binary tree is a binary search tree.
+     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
+     * search tree (BST).
+     * @returns a boolean value.
      */
     isBST(node?: N | null): boolean;
     /**
@@ -327,7 +351,7 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * to 'id'.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
      * can accept a value of type `NodeOrPropertyName`.
-     * @returns The method returns an object of type `AbstractResultsByProperty<T>`.
+     * @returns The method returns an object of type `AbstractBinaryTreeNodeProperties<T>`.
      */
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): AbstractResultsByProperty<N>;
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 }

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

@@ -38,6 +38,15 @@ exports.AbstractBinaryTree = exports.AbstractBinaryTreeNode = void 0;
 var utils_1 = require("../../utils");
 var types_1 = require("../types");
 var AbstractBinaryTreeNode = /** @class */ (function () {
+    /**
+     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * for the binary tree node.
+     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of times the
+     * value `val` appears in the binary tree node. If the `count` parameter is not provided, it defaults to 1.
+     */
     function AbstractBinaryTreeNode(id, val, count) {
         this._familyPosition = types_1.FamilyPosition.ROOT;
         this._count = 1;
@@ -60,8 +69,8 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         get: function () {
             return this._val;
         },
-        set: function (v) {
-            this._val = v;
+        set: function (value) {
+            this._val = value;
         },
         enumerable: false,
         configurable: true
@@ -134,9 +143,14 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * The function swaps the location of two nodes in a binary tree.
+     * @param {FAMILY} swapNode - The `swapNode` parameter is of type `FAMILY`, which represents a node in a family tree.
+     * @returns the `swapNode` object after swapping its properties with the properties of `this` object.
+     */
     AbstractBinaryTreeNode.prototype.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
-        var tempNode = this._createNode(swapNode.id, val);
+        var tempNode = this.createNode(swapNode.id, val);
         if (tempNode instanceof AbstractBinaryTreeNode) {
             tempNode.val = val;
             tempNode.count = count;
@@ -152,8 +166,13 @@ var AbstractBinaryTreeNode = /** @class */ (function () {
         }
         return swapNode;
     };
+    /**
+     * The `clone` function returns a new instance of the `FAMILY` class with the same `id`, `val`, and `count` properties.
+     * @returns The `clone()` method is returning a new instance of the `FAMILY` class with the same `id`, `val`, and
+     * `count` values as the current instance.
+     */
     AbstractBinaryTreeNode.prototype.clone = function () {
-        return this._createNode(this.id, this.val, this.count);
+        return this.createNode(this.id, this.val, this.count);
     };
     return AbstractBinaryTreeNode;
 }());
@@ -317,7 +336,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             return;
         };
         var inserted;
-        var needInsert = val !== null ? this._createNode(id, val !== null && val !== void 0 ? val : id, count) : null;
+        var needInsert = val !== null ? this.createNode(id, val !== null && val !== void 0 ? val : id, count) : null;
         var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
@@ -333,7 +352,7 @@ var AbstractBinaryTree = /** @class */ (function () {
             }
         }
         else {
-            this._setRoot(val !== null ? this._createNode(id, val !== null && val !== void 0 ? val : id, count) : null);
+            this._setRoot(val !== null ? this.createNode(id, val !== null && val !== void 0 ? val : id, count) : null);
             if (needInsert !== null) {
                 this._setSize(1);
                 this._setCount(count);
@@ -343,12 +362,13 @@ var AbstractBinaryTree = /** @class */ (function () {
         return inserted;
     };
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @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.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
+     * either a node object (`N`) or `null`.
+     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
+     * child.
+     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
+     * `undefined` in certain cases.
      */
     AbstractBinaryTree.prototype.addTo = function (newNode, parent) {
         var _a, _b;
@@ -802,15 +822,11 @@ var AbstractBinaryTree = /** @class */ (function () {
         }
     };
     /**
-     * The `isBST` function checks if a binary tree is a binary search tree.
-     * @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
-     * tree, and `false` otherwise.
+     * The function `isBSTByRooted` checks if a binary tree is a binary search tree (BST) by rooted traversal.
+     * @param {N | null} node - The `node` parameter represents the root node of a binary search tree (BST).
+     * @returns a boolean value.
      */
-    AbstractBinaryTree.prototype.isBST = function (node) {
-        node = node !== null && node !== void 0 ? node : this.root;
+    AbstractBinaryTree.prototype.isBSTByRooted = function (node) {
         if (!node)
             return true;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
@@ -840,6 +856,15 @@ var AbstractBinaryTree = /** @class */ (function () {
             return true;
         }
     };
+    /**
+     * The function checks if a binary tree is a binary search tree.
+     * @param {N | null} [node] - The `node` parameter is of type `N` or `null`. It represents the root node of a binary
+     * search tree (BST).
+     * @returns a boolean value.
+     */
+    AbstractBinaryTree.prototype.isBST = function (node) {
+        return this.isBSTByRooted(this.root);
+    };
     /**
      * The function calculates the size and count of a subtree in a binary tree using either recursive or iterative
      * traversal.
@@ -981,7 +1006,7 @@ var AbstractBinaryTree = /** @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 `AbstractResultsByProperty<N>`.
+     * @returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
@@ -1009,7 +1034,7 @@ var AbstractBinaryTree = /** @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 `AbstractResultsByProperty<N>`.
+     * @returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1103,7 +1128,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * 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 `AbstractResultsByProperty<N>`.
+     * @returns The function `levelIterative` returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1133,7 +1158,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * @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 `AbstractResultByProperty<N>` objects.
+     * @returns The function `listLevels` returns a 2D array of `AbstractBinaryTreeNodeProperty<N>` objects.
      */
     AbstractBinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
@@ -1217,7 +1242,7 @@ var AbstractBinaryTree = /** @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 `AbstractResultsByProperty<N>`.
+     * @returns The function `morris` returns an object of type `AbstractBinaryTreeNodeProperties<N>`.
      */
     AbstractBinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
         var _this = this;
@@ -1433,7 +1458,7 @@ var AbstractBinaryTree = /** @class */ (function () {
      * to 'id'.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
      * can accept a value of type `NodeOrPropertyName`.
-     * @returns The method returns an object of type `AbstractResultsByProperty<T>`.
+     * @returns The method returns an object of type `AbstractBinaryTreeNodeProperties<T>`.
      */
     AbstractBinaryTree.prototype._getResultByPropertyName = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';

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

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

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

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

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

@@ -7,10 +7,20 @@
  */
 import type { BinaryTreeNodeId, RecursiveBinaryTreeNode } from '../types';
 import { BinaryTreeOptions } from '../types';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
 import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
+import { IBinaryTree, IBinaryTreeNode } from '../interfaces/binary-tree';
 export declare class BinaryTreeNode<T = number, FAMILY extends BinaryTreeNode<T, FAMILY> = RecursiveBinaryTreeNode<T>> extends AbstractBinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
+    /**
+     * The function creates a new binary tree node with an optional value and count, and returns it as a specified type.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`, which could be a string or a number depending on how you want to identify your nodes.
+     * @param {T} [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the
+     * value stored in the node.
+     * @param {number} [count] - The count parameter is an optional parameter that represents the number of times the value
+     * appears in the binary tree node.
+     * @returns a new instance of the BinaryTreeNode class, casted as the FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
     /**
@@ -30,5 +40,5 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * of occurrences of the value in the binary tree node. If not provided, the default value is `undefined`.
      * @returns a BinaryTreeNode object if the value is not null, otherwise it returns null.
      */
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -29,8 +29,18 @@ var BinaryTreeNode = /** @class */ (function (_super) {
     function BinaryTreeNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    BinaryTreeNode.prototype._createNode = function (id, val, count) {
-        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    /**
+     * The function creates a new binary tree node with an optional value and count, and returns it as a specified type.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`, which could be a string or a number depending on how you want to identify your nodes.
+     * @param {T} [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the
+     * value stored in the node.
+     * @param {number} [count] - The count parameter is an optional parameter that represents the number of times the value
+     * appears in the binary tree node.
+     * @returns a new instance of the BinaryTreeNode class, casted as the FAMILY type.
+     */
+    BinaryTreeNode.prototype.createNode = function (id, val, count) {
+        return new BinaryTreeNode(id, (val === undefined ? id : val), count);
     };
     return BinaryTreeNode;
 }(abstract_binary_tree_1.AbstractBinaryTreeNode));
@@ -56,9 +66,8 @@ var BinaryTree = /** @class */ (function (_super) {
      * of occurrences of the value in the binary tree node. If not provided, the default value is `undefined`.
      * @returns a BinaryTreeNode object if the value is not null, otherwise it returns null.
      */
-    BinaryTree.prototype._createNode = function (id, val, count) {
-        var node = new BinaryTreeNode(id, val, count);
-        return node;
+    BinaryTree.prototype.createNode = function (id, val, count) {
+        return new BinaryTreeNode(id, val === undefined ? id : val, count);
     };
     return BinaryTree;
 }(abstract_binary_tree_1.AbstractBinaryTree));

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

@@ -8,16 +8,37 @@
 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> {
+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?: BSTOptions);
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    /**
+     * The function creates a new binary search tree node with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`.
+     * @param {N['val'] | null} [val] - The `val` parameter is the value that will be stored in the node. It can be of any
+     * type `N['val']` or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of occurrences
+     * of a particular value in the binary search tree node.
+     * @returns a new instance of the BSTNode class, casted as type N.
+     */
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
      * the ID matches, and returns the inserted node.
@@ -49,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.

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

@@ -39,6 +39,19 @@ var BSTNode = /** @class */ (function (_super) {
     function BSTNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function creates a new binary search tree node with the specified id, value, and count.
+     * @param {BinaryTreeNodeId} id - The id parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The "val" parameter represents the value that will be stored in the binary tree node. It is an
+     * optional parameter, meaning it can be omitted when calling the "createNode" function.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary
+     * search tree node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the FAMILY type.
+     */
+    BSTNode.prototype.createNode = function (id, val, count) {
+        return new BSTNode(id, (val === undefined ? id : val), count);
+    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
@@ -59,9 +72,18 @@ var BST = /** @class */ (function (_super) {
         }
         return _this;
     }
-    BST.prototype._createNode = function (id, val, count) {
-        var node = val !== null ? new BSTNode(id, val, count) : null;
-        return node;
+    /**
+     * The function creates a new binary search tree node with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
+     * `BinaryTreeNodeId`.
+     * @param {N['val'] | null} [val] - The `val` parameter is the value that will be stored in the node. It can be of any
+     * type `N['val']` or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of occurrences
+     * of a particular value in the binary search tree node.
+     * @returns a new instance of the BSTNode class, casted as type N.
+     */
+    BST.prototype.createNode = function (id, val, count) {
+        return new BSTNode(id, val === 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
@@ -78,7 +100,7 @@ var BST = /** @class */ (function (_super) {
     BST.prototype.add = function (id, val, count) {
         if (count === void 0) { count = 1; }
         var inserted = null;
-        var newNode = this._createNode(id, val, count);
+        var newNode = this.createNode(id, val, count);
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);

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