min-heap-typed 1.42.5 → 1.42.7

package/src/data-structures/binary-tree/bst.ts

@@ -12,7 +12,8 @@ import {IBinaryTree} from '../../interfaces';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  override parent: N | undefined;
+  override parent?: N ;
+
   constructor(key: BTNKey, value?: V) {
     super(key, value);
     this.parent = undefined;
@@ -20,7 +21,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
     this._right = undefined;
   }
 
-  protected override _left: N | undefined;
+  protected override _left?: N ;
 
   /**
    * Get the left child node.
@@ -41,7 +42,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 
 
-  protected override _right: N | undefined;
+  protected override _right?: N ;
 
   /**
    * Get the right child node.
@@ -64,8 +65,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -82,7 +82,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       }
     }
   }
-  protected override _root: N | undefined = undefined;
+
+  protected override _root?: N ;
 
   /**
    * Get the root node of the binary tree.
@@ -114,16 +115,13 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * was not added or if the parameters were invalid, it returns undefined or undefined.
    */
   override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
-    if (keyOrNode === 8) {
-      debugger
-    }
     if (keyOrNode === null) return undefined;
     // TODO support node as a parameter
-    let inserted:N | undefined;
-    let newNode:N | undefined;
+    let inserted: N | undefined;
+    let newNode: N | undefined;
     if (keyOrNode instanceof BSTNode) {
       newNode = keyOrNode;
-    } else if (typeof keyOrNode === 'number') {
+    } else if (this.isNodeKey(keyOrNode)) {
       newNode = this.createNode(keyOrNode, value);
     } else {
       newNode = undefined;
@@ -196,59 +194,60 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * It can have two possible values:
    * @returns The `addMany` function returns an array of `N`, `undefined`, or `undefined` values.
    */
-
   override addMany(
-    keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[],
-    data?: V[],
+    keysOrNodes: (BTNKey | N | undefined)[],
+    data?: (V | undefined)[],
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | undefined)[] {
     // TODO this addMany function is inefficient, it should be optimized
-    function hasNoNull(arr: (BTNKey | undefined)[] | (N | undefined)[]): arr is BTNKey[] | N[] {
+    function hasNoUndefined(arr: (BTNKey | N | undefined)[]): arr is (BTNKey | N)[] {
       return arr.indexOf(undefined) === -1;
     }
 
-    if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
+    if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
       return super.addMany(keysOrNodes, data).map(n => n ?? undefined);
     }
+    
     const inserted: (N | undefined)[] = [];
     const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
       (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
     );
+    
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
+    function _isNodeOrUndefinedTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, V][]): arr is [BTNKey, V][] {
-      for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
+    const _isBinaryTreeKeyOrNullTuple = (arr: [BTNKey | N, V][]): arr is [BTNKey, V][] => {
+      for (const [keyOrNode] of arr) if (this.isNodeKey(keyOrNode)) return true;
       return false;
     }
 
     let sortedKeysOrNodes: (number | N | undefined)[] = [],
       sortedData: (V | undefined)[] | undefined = [];
 
-    if (isNodeOrNullTuple(combinedArr)) {
+    if (_isNodeOrUndefinedTuple(combinedArr)) {
       sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
-    } else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
+    } else if (_isBinaryTreeKeyOrNullTuple(combinedArr)) {
       sorted = combinedArr.sort((a, b) => a[0] - b[0]);
     } else {
       throw new Error('Invalid input keysOrNodes');
     }
     sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
     sortedData = sorted.map(([, value]) => value);
-    const recursive = (arr: (BTNKey | undefined | N)[], data?: (V | undefined)[]) => {
+    const _dfs = (arr: (BTNKey | undefined | N)[], data?: (V | undefined)[]) => {
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
       const newNode = this.add(arr[mid], data?.[mid]);
       inserted.push(newNode);
-      recursive(arr.slice(0, mid), data?.slice(0, mid));
-      recursive(arr.slice(mid + 1), data?.slice(mid + 1));
+      _dfs(arr.slice(0, mid), data?.slice(0, mid));
+      _dfs(arr.slice(mid + 1), data?.slice(mid + 1));
     };
-    const iterative = () => {
+    const _iterate = () => {
       const n = sorted.length;
       const stack: [[number, number]] = [[0, n - 1]];
       while (stack.length > 0) {
@@ -266,9 +265,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       }
     };
     if (iterationType === IterationType.RECURSIVE) {
-      recursive(sortedKeysOrNodes, sortedData);
+      _dfs(sortedKeysOrNodes, sortedData);
     } else {
-      iterative();
+      _iterate();
     }
 
     return inserted;
@@ -289,12 +288,61 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * the key of the leftmost node if the comparison result is greater than, and the key of the
    * rightmost node otherwise. If no node is found, it returns 0.
    */
-  lastKey(beginRoot: N | undefined = this.root, iterationType = this.iterationType): BTNKey {
+  lastKey(beginRoot: BTNKey | N | undefined = this.root, iterationType = this.iterationType): BTNKey {
     if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
     else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
   }
 
+  /**
+   * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+   * either recursive or iterative methods.
+   * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+   * It is used to find the node with the matching key value.
+   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+   * type of iteration to use when searching for a node in the binary tree. It can have two possible
+   * values:
+   * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+   * found in the binary tree. If no node is found, it returns `undefined`.
+   */
+  override getNodeByKey(key: BTNKey, iterationType = IterationType.ITERATIVE): N | undefined {
+    if (!this.root) return undefined;
+    if (iterationType === IterationType.RECURSIVE) {
+      const _dfs = (cur: N): N | undefined => {
+        if (cur.key === key) return cur;
+        if (!cur.left && !cur.right) return;
+        
+        if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
+      };
+
+      return _dfs(this.root);
+    } else {
+      const queue = new Queue<N>([this.root]);
+      while (queue.size > 0) {
+        const cur = queue.shift();
+        if (cur) {
+          if (this._compare(cur.key, key) === CP.eq) return cur;
+          if (this._compare(cur.key, key) === CP.gt) cur.left && queue.push(cur.left);
+          if (this._compare(cur.key, key) === CP.lt) cur.right && queue.push(cur.right);
+        }
+      }
+    }
+  }
+
+  /**
+   * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+   * otherwise it returns the key itself.
+   * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+   * `undefined`.
+   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+   * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+   * @returns either a node object (N) or undefined.
+   */
+  override ensureNotKey(key: BTNKey | N | undefined, iterationType = IterationType.ITERATIVE): N | undefined {
+    return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+  }
+
   /**
    * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
    * using either recursive or iterative traversal.
@@ -303,7 +351,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * generic type `N`.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-   * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, which is
+   * included in the result. The default value for `callback` is `this._defaultOneParamCallback`, which is
    * a
    * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
    * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -318,11 +366,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   override getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | undefined,
-    callback: C = this.defaultOneParamCallback as C,
+    callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
-    beginRoot: N | undefined = this.root,
+    beginRoot: BTNKey | N | undefined = this.root,
     iterationType = this.iterationType
   ): N[] {
+    beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return [];
     const ans: N[] = [];
 
@@ -336,7 +385,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
         if (!cur.left && !cur.right) return;
         // TODO potential bug
-        if (callback === this.defaultOneParamCallback) {
+        if (callback === this._defaultOneParamCallback) {
           if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && _traverse(cur.left);
           if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && _traverse(cur.right);
         } else {
@@ -357,7 +406,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this.defaultOneParamCallback) {
+          if (callback === this._defaultOneParamCallback) {
             if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && queue.push(cur.left);
             if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && queue.push(cur.right);
           } else {
@@ -391,17 +440,18 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
   lesserOrGreaterTraverse<C extends BTNCallback<N>>(
-    callback: C = this.defaultOneParamCallback as C,
+    callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BTNKey | N | undefined = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
-    if (typeof targetNode === 'number') targetNode = this.getNode(targetNode) ?? undefined;
+    targetNode = this.ensureNotKey(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
-    const targetKey = targetNode.key;
     if (!this.root) return ans;
 
+    const targetKey = targetNode.key;
+
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (cur: N) => {
         const compared = this._compare(cur.key, targetKey);
@@ -509,7 +559,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     } else {
       const stack: N[] = [];
       let node: N | undefined = this.root,
-        last:N | undefined = undefined;
+        last: N | undefined = undefined;
       const depths: Map<N, number> = new Map();
 
       while (stack.length > 0 || node) {

package/src/data-structures/binary-tree/rb-tree.ts

@@ -7,19 +7,19 @@
  */
 
 import {
-  BinaryTreeDeletedResult,
+  BiTreeDeleteResult,
   BTNCallback,
   BTNKey,
   IterationType,
   RBTNColor,
-  RBTreeNodeNested,
+  RedBlackTreeNodeNested,
   RBTreeOptions
 } from '../../types';
 import {BST, BSTNode} from "./bst";
 import {IBinaryTree} from "../../interfaces";
 import {BinaryTreeNode} from "./binary-tree";
 
-export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
+export class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
   color: RBTNColor;
   constructor(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK) {
     super(key, value);
@@ -34,7 +34,7 @@ export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
+export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>>
   extends BST<V, N>
   implements IBinaryTree<V, N>
 {
@@ -56,13 +56,21 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
     return this._size;
   }
 
-  NIL: N = new RBTreeNode<V>(NaN) as unknown as N;
+  NIL: N = new RedBlackTreeNode<V>(NaN) as unknown as N;
 
+  /**
+   * The `add` function adds a new node to a Red-Black Tree data structure.
+   * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
+   * following types:
+   * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+   * key in the node being added to the Red-Black Tree.
+   * @returns The method returns either a node (`N`) or `undefined`.
+   */
   override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
     let node: N;
-    if (typeof keyOrNode === 'number') {
+    if (this.isNodeKey(keyOrNode)) {
       node = this.createNode(keyOrNode, value, RBTNColor.RED);
-    } else if(keyOrNode instanceof RBTreeNode) {
+    } else if(keyOrNode instanceof RedBlackTreeNode) {
       node = keyOrNode;
     } else if (keyOrNode === null) {
       return;
@@ -112,15 +120,26 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
   }
 
   override createNode(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK): N {
-    return new RBTreeNode<V, N>(key, value, color) as N;
+    return new RedBlackTreeNode<V, N>(key, value, color) as N;
   }
-
-
+  
+  /**
+   * The `delete` function removes a node from a binary tree based on a given identifier and updates
+   * the tree accordingly.
+   * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+   * that you want to use to identify the node that you want to delete from the binary tree. It can be
+   * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
+   * you don't want to
+   * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
+   * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
+   * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
+   * @returns an array of `BiTreeDeleteResult<N>`.
+   */
   delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this.defaultOneParamCallback as C
-  ): BinaryTreeDeletedResult<N>[] {
-    const ans: BinaryTreeDeletedResult<N>[] = [];
+    callback: C = this._defaultOneParamCallback as C
+  ): BiTreeDeleteResult<N>[] {
+    const ans: BiTreeDeleteResult<N>[] = [];
     if (identifier === null) return ans;
     const helper = (node: N | undefined): void => {
       let z: N = this.NIL;
@@ -151,7 +170,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
         x = z.left;
         this._rbTransplant(z, z.left!);
       } else {
-        y = this.getLeftMost(z.right);
+        y = this.getLeftMost(z.right)!;
         yOriginalColor = y.color;
         x = y.right;
         if (y.parent === z) {
@@ -177,7 +196,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
     return ans;
   }
 
-  isNode(node: N | undefined): node is N {
+  override isRealNode(node: N | undefined): node is N {
     return node !== this.NIL && node !== undefined;
   }
 
@@ -210,7 +229,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired criteria. It takes a node as input and returns a boolean value indicating
    * whether the node matches the criteria or not. The default callback function
-   * (`this.defaultOneParamCallback`) is used if no callback function is
+   * (`this._defaultOneParamCallback`) is used if no callback function is
    * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
    * the root node from which the search should begin.
    * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
@@ -219,48 +238,23 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
    */
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | undefined,
-    callback: C = this.defaultOneParamCallback as C,
-    beginRoot = this.root,
+    callback: C = this._defaultOneParamCallback as C,
+    beginRoot: BTNKey | N | undefined = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-
+    beginRoot = this.ensureNotKey(beginRoot);
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
-  /**
-   * The function returns the leftmost node in a red-black tree.
-   * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
-   * a Red-Black Tree.
-   * @returns The leftmost node in the given RBTreeNode.
-   */
-  getLeftMost(node: N = this.root): N {
-    while (node.left !== undefined && node.left !== this.NIL) {
-      node = node.left;
-    }
-    return node;
-  }
-
-  /**
-   * The function returns the rightmost node in a red-black tree.
-   * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
-   * @returns the rightmost node in a red-black tree.
-   */
-  getRightMost(node: N): N {
-    while (node.right !== undefined && node.right !== this.NIL) {
-      node = node.right;
-    }
-    return node;
-  }
-
   /**
    * The function returns the successor of a given node in a red-black tree.
-   * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
-   * @returns the successor of the given RBTreeNode.
+   * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
+   * @returns the successor of the given RedBlackTreeNode.
    */
-  getSuccessor(x: N): N | undefined {
+  override getSuccessor(x: N): N | undefined {
     if (x.right !== this.NIL) {
-      return this.getLeftMost(x.right);
+      return this.getLeftMost(x.right) ?? undefined;
     }
 
     let y: N | undefined = x.parent;
@@ -273,13 +267,13 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The function returns the predecessor of a given node in a red-black tree.
-   * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+   * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
    * Red-Black Tree.
-   * @returns the predecessor of the given RBTreeNode 'x'.
+   * @returns the predecessor of the given RedBlackTreeNode 'x'.
    */
-  getPredecessor(x: N): N {
+  override getPredecessor(x: N): N {
     if (x.left !== this.NIL) {
-      return this.getRightMost(x.left!);
+      return this.getRightMost(x.left!)!;
     }
 
     let y: N | undefined = x.parent;
@@ -305,7 +299,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The function performs a left rotation on a red-black tree node.
-   * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
+   * @param {RedBlackTreeNode} x - The parameter `x` is a RedBlackTreeNode object.
    */
   protected _leftRotate(x: N): void {
     if (x.right) {
@@ -329,7 +323,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The function performs a right rotation on a red-black tree node.
-   * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
+   * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
    * rotated.
    */
   protected _rightRotate(x: N): void {
@@ -354,7 +348,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
-   * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+   * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
    * red-black tree.
    */
   protected _fixDelete(x: N): void {
@@ -419,8 +413,8 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-   * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
-   * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
+   * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
+   * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
    */
   protected _rbTransplant(u: N, v: N): void {
     if (u.parent === undefined) {
@@ -435,7 +429,7 @@ export class RedBlackTree<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RB
 
   /**
    * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-   * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
+   * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
    * red-black tree.
    */
   protected _fixInsert(k: N): void {