red-black-tree-typed 1.53.7 → 1.54.1

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

@@ -3,6 +3,8 @@ export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './rb-tree';
+export * from './red-black-tree';
 export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
+export * from './tree-counter';
+export * from './avl-tree-counter';

package/src/data-structures/binary-tree/{rb-tree.ts → red-black-tree.ts}

@@ -2,80 +2,132 @@ import type {
   BinaryTreeDeleteResult,
   BTNRep,
   CRUD,
+  EntryCallback,
   OptNode,
+  OptNodeOrNull,
   RBTNColor,
-  RBTreeOptions,
-  RedBlackTreeNested,
-  RedBlackTreeNodeNested
+  RedBlackTreeOptions
 } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
-export class RedBlackTreeNode<
-  K = any,
-  V = any,
-  NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>
-> extends BSTNode<K, V, NODE> {
+export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
   /**
-   * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
-   * color.
-   * @param {K} key - The key parameter is of type K and represents the key of the node in the
-   * Red-Black Tree.
-   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-   * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
-   * creating a new instance of the Red-Black Tree Node.
-   * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-   * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
+   * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
+   * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
+   * Red-Black Tree data structure.
+   * @param {V} [value] - The `value` parameter in the constructor is an optional parameter of type
+   * `V`. It represents the value associated with the key in the data structure being constructed.
+   * @param {RBTNColor} [color=BLACK] - The `color` parameter in the constructor is used to specify the
+   * color of the node in a Red-Black Tree. It has a default value of 'BLACK' if not provided
+   * explicitly.
    */
   constructor(key: K, value?: V, color: RBTNColor = 'BLACK') {
     super(key, value);
     this._color = color;
   }
 
-  protected _color: RBTNColor;
+  override parent?: RedBlackTreeNode<K, V> = undefined;
 
-  /**
-   * The function returns the color value of a variable.
-   * @returns The color value stored in the private variable `_color`.
-   */
-  get color(): RBTNColor {
-    return this._color;
+  override _left?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
+
+  override get left(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+    return this._left;
   }
 
-  /**
-   * The function sets the color property to the specified value.
-   * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-   */
-  set color(value: RBTNColor) {
-    this._color = value;
+  override set left(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+    if (v) {
+      v.parent = this;
+    }
+    this._left = v;
+  }
+
+  override _right?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
+
+  override get right(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+    return this._right;
+  }
+
+  override set right(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+    if (v) {
+      v.parent = this;
+    }
+    this._right = v;
   }
 }
 
 /**
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ * @example
+ * // Find elements in a range
+ *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
+ *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ * @example
+ * // using Red-Black Tree as a price-based index for stock data
+ *     // Define the structure of individual stock records
+ *     interface StockRecord {
+ *       price: number; // Stock price (key for indexing)
+ *       symbol: string; // Stock ticker symbol
+ *       volume: number; // Trade volume
+ *     }
+ *
+ *     // Simulate stock market data as it might come from an external feed
+ *     const marketStockData: StockRecord[] = [
+ *       { price: 142.5, symbol: 'AAPL', volume: 1000000 },
+ *       { price: 335.2, symbol: 'MSFT', volume: 800000 },
+ *       { price: 3285.04, symbol: 'AMZN', volume: 500000 },
+ *       { price: 267.98, symbol: 'META', volume: 750000 },
+ *       { price: 234.57, symbol: 'GOOGL', volume: 900000 }
+ *     ];
+ *
+ *     // Extend the stock record type to include metadata for database usage
+ *     type StockTableRecord = StockRecord & { lastUpdated: Date };
+ *
+ *     // Create a Red-Black Tree to index stock records by price
+ *     // Simulates a database index with stock price as the key for quick lookups
+ *     const priceIndex = new RedBlackTree<number, StockTableRecord, StockRecord>(marketStockData, {
+ *       toEntryFn: stockRecord => [
+ *         stockRecord.price, // Use stock price as the key
+ *         {
+ *           ...stockRecord,
+ *           lastUpdated: new Date() // Add a timestamp for when the record was indexed
+ *         }
+ *       ]
+ *     });
+ *
+ *     // Query the stock with the highest price
+ *     const highestPricedStock = priceIndex.getRightMost();
+ *     console.log(priceIndex.get(highestPricedStock)?.symbol); // 'AMZN' // Amazon has the highest price
+ *
+ *     // Query stocks within a specific price range (200 to 400)
+ *     const stocksInRange = priceIndex.rangeSearch(
+ *       [200, 400], // Price range
+ *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
+ *     );
+ *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
  */
-export class RedBlackTree<
-    K = any,
-    V = any,
-    R = object,
-    NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
-    TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>
-  >
-  extends BST<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
+  extends BST<K, V, R, MK, MV, MR>
+  implements IBinaryTree<K, V, R, MK, MV, MR>
 {
   /**
-   * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-   * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-   * initialize the RBTree with the provided elements.
-   * @param [options] - The `options` parameter is an optional object that can be passed to the
-   * constructor. It is of type `RBTreeOptions<K, V, R>`. This object can contain various options for
-   * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
-   * depend on the implementation
+   * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
+   * raw data.
+   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+   * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+   * is used to initialize the Red-Black Tree with keys, nodes, entries, or
+   * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
+   * V, R>`. It is an optional parameter that allows you to specify additional options for the
+   * RedBlackTree class. These options could include configuration settings, behavior customization, or
+   * any other parameters that are specific to
    */
-  constructor(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, NODE>> = [], options?: RBTreeOptions<K, V, R>) {
+  constructor(
+    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, RedBlackTreeNode<K, V>> | R> = [],
+    options?: RedBlackTreeOptions<K, V, R>
+  ) {
     super([], options);
 
     this._root = this.NIL;
@@ -85,17 +137,16 @@ export class RedBlackTree<
     }
   }
 
-  protected override _root: NODE | undefined;
+  protected override _root: RedBlackTreeNode<K, V> | undefined;
 
-  /**
-   * The function returns the root node of a tree or undefined if there is no root.
-   * @returns The root node of the tree structure, or undefined if there is no root node.
-   */
-  override get root(): NODE | undefined {
+  override get root(): RedBlackTreeNode<K, V> | undefined {
     return this._root;
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function creates a new Red-Black Tree node with the specified key, value, and color.
    * @param {K} key - The key parameter represents the key value of the node being created. It is of
    * type K, which is a generic type that can be replaced with any specific type when using the
@@ -109,24 +160,27 @@ export class RedBlackTree<
    * @returns A new instance of a RedBlackTreeNode with the specified key, value, and color is being
    * returned.
    */
-  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): NODE {
-    return new RedBlackTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value, color) as NODE;
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
+    return new RedBlackTreeNode<K, V>(key, this._isMapMode ? undefined : value, color);
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function creates a new Red-Black Tree with the specified options.
    * @param [options] - The `options` parameter is an optional object that contains additional
    * configuration options for creating the Red-Black Tree. It has the following properties:
    * @returns a new instance of a RedBlackTree object.
    */
-  override createTree(options?: RBTreeOptions<K, V, R>): TREE {
-    return new RedBlackTree<K, V, R, NODE, TREE>([], {
+  override createTree(options?: RedBlackTreeOptions<K, V, R>) {
+    return new RedBlackTree<K, V, R, MK, MV, MR>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       ...options
-    }) as TREE;
+    });
   }
 
   /**
@@ -134,51 +188,15 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-   * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+   * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `RedBlackTreeNode` class.
    */
-  override isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE {
-    return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
+  override isNode(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>): keyNodeOrEntry is RedBlackTreeNode<K, V> {
+    return keyNodeOrEntry instanceof RedBlackTreeNode;
   }
 
-  // /**
-  //  * Time Complexity: O(1)
-  //  * Space Complexity: O(1)
-  //  */
-  //
-  // /**
-  //  * Time Complexity: O(1)
-  //  * Space Complexity: O(1)
-  //  *
-  //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
-  //  * valid, otherwise it returns undefined.
-  //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
-  //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
-  //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
-  //  */
-  // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
-  //
-  //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
-  //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
-  //
-  //   if (this._toEntryFn) {
-  //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
-  //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
-  //   }
-  //
-  //   if (this.isEntry(keyNodeEntryOrRaw)) {
-  //     const [key, value] = keyNodeEntryOrRaw;
-  //     if (key === undefined || key === null) return;
-  //     else return  this.createNode(key, value, 'RED');
-  //   }
-  //
-  //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
-  //
-  //   return ;
-  // }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -193,12 +211,12 @@ export class RedBlackTree<
 
   /**
    * Time Complexity: O(log n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(log n)
    *
    * The function adds a new node to a binary search tree and returns true if the node was successfully
    * added.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-   * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
    * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
    * the key in the data structure. It represents the value that you want to add or update in the data
    * structure.
@@ -206,8 +224,8 @@ export class RedBlackTree<
    * the method returns true. If the node already exists and its value is updated, the method also
    * returns true. If the node cannot be added or updated, the method returns false.
    */
-  override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+  override add(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>, value?: V): boolean {
+    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (!this.isRealNode(newNode)) return false;
 
     const insertStatus = this._insert(newNode);
@@ -232,36 +250,40 @@ export class RedBlackTree<
 
   /**
    * Time Complexity: O(log n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(log n)
    *
    * The function overrides the delete method in a binary tree data structure to remove a node based on
    * a given predicate and maintain the binary search tree properties.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override delete` method is used to specify the condition or key based on which a
    * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
    * function that determines which node(s) should be deleted.
-   * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<NODE>`
+   * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>`
    * objects. Each object in the array contains information about the deleted node and whether
    * balancing is needed.
    */
-  override delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[] {
-    if (keyNodeEntryOrRaw === null) return [];
+  override delete(
+    keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>
+  ): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[] {
+    if (keyNodeOrEntry === null) return [];
 
-    const results: BinaryTreeDeleteResult<NODE>[] = [];
-    let nodeToDelete: OptNode<NODE>;
-    if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
-    else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
+    const results: BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[] = [];
+    let nodeToDelete: OptNode<RedBlackTreeNode<K, V>>;
+    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
+    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
 
     if (!nodeToDelete) {
       return results;
     }
 
     let originalColor = nodeToDelete.color;
-    let replacementNode: NODE | undefined;
+    let replacementNode: RedBlackTreeNode<K, V> | undefined;
 
     if (!this.isRealNode(nodeToDelete.left)) {
-      replacementNode = nodeToDelete.right;
-      this._transplant(nodeToDelete, nodeToDelete.right);
+      if (nodeToDelete.right !== null) {
+        replacementNode = nodeToDelete.right;
+        this._transplant(nodeToDelete, nodeToDelete.right);
+      }
     } else if (!this.isRealNode(nodeToDelete.right)) {
       replacementNode = nodeToDelete.left;
       this._transplant(nodeToDelete, nodeToDelete.left);
@@ -269,15 +291,17 @@ export class RedBlackTree<
       const successor = this.getLeftMost(node => node, nodeToDelete.right);
       if (successor) {
         originalColor = successor.color;
-        replacementNode = successor.right;
+        if (successor.right !== null) replacementNode = successor.right;
 
         if (successor.parent === nodeToDelete) {
           if (this.isRealNode(replacementNode)) {
             replacementNode.parent = successor;
           }
         } else {
-          this._transplant(successor, successor.right);
-          successor.right = nodeToDelete.right;
+          if (successor.right !== null) {
+            this._transplant(successor, successor.right);
+            successor.right = nodeToDelete.right;
+          }
           if (this.isRealNode(successor.right)) {
             successor.right.parent = successor;
           }
@@ -304,15 +328,62 @@ export class RedBlackTree<
     return results;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+   * applying a callback to each entry in the original tree.
+   * @param callback - A function that will be called for each entry in the tree, with parameters
+   * representing the key, value, index, and the tree itself. It should return an entry for the new
+   * tree.
+   * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+   * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+   * Tree that will be created during the mapping process. These options could include things like
+   * custom comparators
+   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+   * the value of `this` when executing the `callback` function. It allows you to set the context
+   * (value of `this`) for the callback function. This can be useful when you want to access properties
+   * or
+   * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+   * provided callback function.
+   */
+  override map(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: RedBlackTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ): RedBlackTree<MK, MV, MR> {
+    const newTree = new RedBlackTree<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
+    }
+    return newTree;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+   * structure.
+   * @returns The `cloned` object is being returned.
+   */
+  override clone() {
+    const cloned = this.createTree();
+    this._clone(cloned);
+    return cloned;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The function sets the root of a tree-like structure and updates the parent property of the new
    * root.
-   * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+   * @param {RedBlackTreeNode<K, V> | undefined} v - v is a parameter of type RedBlackTreeNode<K, V> or undefined.
    */
-  protected override _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: RedBlackTreeNode<K, V> | undefined) {
     if (v) {
       v.parent = undefined;
     }
@@ -324,14 +395,17 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function replaces an old node with a new node while preserving the color of the old node.
-   * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+   * @param {RedBlackTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
    * the data structure.
-   * @param {NODE} newNode - The `newNode` parameter is of type `NODE`, which represents a node in a
+   * @param {RedBlackTreeNode<K, V>} newNode - The `newNode` parameter is of type `RedBlackTreeNode<K, V>`, which represents a node in a
    * data structure.
    * @returns The method is returning the result of calling the `_replaceNode` method from the
    * superclass, with the `oldNode` and `newNode` parameters.
    */
-  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(
+    oldNode: RedBlackTreeNode<K, V>,
+    newNode: RedBlackTreeNode<K, V>
+  ): RedBlackTreeNode<K, V> {
     newNode.color = oldNode.color;
 
     return super._replaceNode(oldNode, newNode);
@@ -339,19 +413,19 @@ export class RedBlackTree<
 
   /**
    * Time Complexity: O(log n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(log n)
    *
    * The `_insert` function inserts a node into a binary search tree and performs necessary fix-ups to
    * maintain the red-black tree properties.
-   * @param {NODE} node - The `node` parameter represents the node that needs to be inserted into the
+   * @param {RedBlackTreeNode<K, V>} node - The `node` parameter represents the node that needs to be inserted into the
    * binary search tree.
    * @returns a string value indicating the result of the insertion operation. It can return either
    * 'UPDATED' if the node with the same key already exists and was updated, or 'CREATED' if a new node
    * was created and inserted into the tree.
    */
-  protected _insert(node: NODE): CRUD {
+  protected _insert(node: RedBlackTreeNode<K, V>): CRUD {
     let current = this.root;
-    let parent: NODE | undefined = undefined;
+    let parent: RedBlackTreeNode<K, V> | undefined = undefined;
 
     while (this.isRealNode(current)) {
       parent = current;
@@ -370,7 +444,7 @@ export class RedBlackTree<
 
     if (!parent) {
       this._setRoot(node);
-    } else if (node.key < parent.key) {
+    } else if (this._compare(node.key, parent.key) < 0) {
       parent.left = node;
     } else {
       parent.right = node;
@@ -389,11 +463,11 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function `_transplant` is used to replace a node `u` with another node `v` in a binary tree.
-   * @param {NODE} u - The parameter "u" represents a node in a binary tree.
-   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`, which means it can
-   * either be a `NODE` object or `undefined`.
+   * @param {RedBlackTreeNode<K, V>} u - The parameter "u" represents a node in a binary tree.
+   * @param {RedBlackTreeNode<K, V> | undefined} v - The parameter `v` is of type `RedBlackTreeNode<K, V> | undefined`, which means it can
+   * either be a `RedBlackTreeNode<K, V>` object or `undefined`.
    */
-  protected _transplant(u: NODE, v: NODE | undefined): void {
+  protected _transplant(u: RedBlackTreeNode<K, V>, v: RedBlackTreeNode<K, V> | undefined): void {
     if (!u.parent) {
       this._setRoot(v);
     } else if (u === u.parent.left) {
@@ -412,10 +486,10 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The `_insertFixup` function is used to fix the Red-Black Tree after inserting a new node.
-   * @param {NODE | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
+   * @param {RedBlackTreeNode<K, V> | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
    * structure. It can either be a valid node or `undefined`.
    */
-  protected _insertFixup(z: NODE | undefined): void {
+  protected _insertFixup(z: RedBlackTreeNode<K, V> | undefined): void {
     // Continue fixing the tree as long as the parent of z is red
     while (z?.parent?.color === 'RED') {
       // Check if the parent of z is the left child of its parent
@@ -448,7 +522,7 @@ export class RedBlackTree<
       } else {
         // Symmetric case for the right child (left and right exchanged)
         // Follow the same logic as above with left and right exchanged
-        const y: NODE | undefined = z?.parent?.parent?.left;
+        const y: RedBlackTreeNode<K, V> | undefined = z?.parent?.parent?.left ?? undefined;
         if (y?.color === 'RED') {
           z.parent.color = 'BLACK';
           y.color = 'BLACK';
@@ -479,12 +553,12 @@ export class RedBlackTree<
    *
    * The `_deleteFixup` function is used to fix the red-black tree after a node deletion by adjusting
    * the colors and performing rotations.
-   * @param {NODE | undefined} node - The `node` parameter represents a node in a binary tree. It can
+   * @param {RedBlackTreeNode<K, V> | undefined} node - The `node` parameter represents a node in a binary tree. It can
    * be either a valid node object or `undefined`.
    * @returns The function does not return any value. It has a return type of `void`, which means it
    * does not return anything.
    */
-  protected _deleteFixup(node: NODE | undefined): void {
+  protected _deleteFixup(node: RedBlackTreeNode<K, V> | undefined): void {
     // Early exit condition
     if (!node || node === this.root || node.color === 'BLACK') {
       if (node) {
@@ -494,7 +568,7 @@ export class RedBlackTree<
     }
 
     while (node && node !== this.root && node.color === 'BLACK') {
-      const parent: NODE | undefined = node.parent;
+      const parent: RedBlackTreeNode<K, V> | undefined = node.parent;
 
       if (!parent) {
         break; // Ensure the loop terminates if there's an issue with the tree structure
@@ -561,11 +635,11 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The `_leftRotate` function performs a left rotation on a given node in a binary tree.
-   * @param {NODE | undefined} x - The parameter `x` is of type `NODE | undefined`. It represents a
+   * @param {RedBlackTreeNode<K, V> | undefined} x - The parameter `x` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
    * node in a binary tree or `undefined` if there is no node.
    * @returns void, which means it does not return any value.
    */
-  protected _leftRotate(x: NODE | undefined): void {
+  protected _leftRotate(x: RedBlackTreeNode<K, V> | undefined): void {
     if (!x || !x.right) {
       return;
     }
@@ -596,11 +670,11 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The `_rightRotate` function performs a right rotation on a given node in a binary tree.
-   * @param {NODE | undefined} y - The parameter `y` is of type `NODE | undefined`. It represents a
+   * @param {RedBlackTreeNode<K, V> | undefined} y - The parameter `y` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
    * node in a binary tree or `undefined` if there is no node.
    * @returns void, which means it does not return any value.
    */
-  protected _rightRotate(y: NODE | undefined): void {
+  protected _rightRotate(y: RedBlackTreeNode<K, V> | undefined): void {
     if (!y || !y.left) {
       return;
     }