doubly-linked-list-typed 1.53.6 → 1.53.8

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

@@ -11,6 +11,7 @@ import type {
   BSTNOptKeyOrNode,
   BSTOptions,
   BTNRep,
+  Comparable,
   Comparator,
   CP,
   DFSOrderPattern,
@@ -23,6 +24,7 @@ import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 import { isComparable } from '../../utils';
+import { Range } from '../../common';
 
 export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<
   K,
@@ -92,6 +94,62 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ * @example
+ * // Merge 3 sorted datasets
+ *     const dataset1 = new BST<number, string>([
+ *       [1, 'A'],
+ *       [7, 'G']
+ *     ]);
+ *     const dataset2 = [
+ *       [2, 'B'],
+ *       [6, 'F']
+ *     ];
+ *     const dataset3 = new BST<number, string>([
+ *       [3, 'C'],
+ *       [5, 'E'],
+ *       [4, 'D']
+ *     ]);
+ *
+ *     // Merge datasets into a single BinarySearchTree
+ *     const merged = new BST<number, string>(dataset1);
+ *     merged.addMany(dataset2);
+ *     merged.merge(dataset3);
+ *
+ *     // Verify merged dataset is in sorted order
+ *     console.log([...merged.values()]); // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+ * @example
+ * // Find elements in a range
+ *     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [10, 5, 7]
+ *     console.log(bst.rangeSearch([4, 12], node => node.key.toString())); // ['10', '12', '5', '7']
+ *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
+ *     console.log(bst.rangeSearch([15, 20])); // [15, 18]
+ *     console.log(bst.search(new Range(15, 20, false))); // [18]
+ * @example
+ * // Find lowest common ancestor
+ *     const bst = new BST<number>([20, 10, 30, 5, 15, 25, 35, 3, 7, 12, 18]);
+ *
+ *     // LCA helper function
+ *     const findLCA = (num1: number, num2: number): number | undefined => {
+ *       const path1 = bst.getPathToRoot(num1);
+ *       const path2 = bst.getPathToRoot(num2);
+ *       // Find the first common ancestor
+ *       return findFirstCommon(path1, path2);
+ *     };
+ *
+ *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+ *       for (const num of arr1) {
+ *         if (arr2.indexOf(num) !== -1) {
+ *           return num;
+ *         }
+ *       }
+ *       return undefined;
+ *     }
+ *
+ *     // Assertions
+ *     console.log(findLCA(3, 10)); // 7
+ *     console.log(findLCA(5, 35)); // 15
+ *     console.log(findLCA(20, 30)); // 25
  */
 export class BST<
     K = any,
@@ -115,8 +173,9 @@ export class BST<
     super([], options);
 
     if (options) {
-      const { comparator } = options;
-      if (comparator) this._comparator = comparator;
+      const { extractComparable, isReverse } = options;
+      if (typeof extractComparable === 'function') this._extractComparable = extractComparable;
+      if (isReverse !== undefined) this._isReverse = isReverse;
     }
 
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
@@ -132,6 +191,17 @@ export class BST<
     return this._root;
   }
 
+  protected _isReverse: boolean = false;
+
+  /**
+   * The above function is a getter method in TypeScript that returns the value of the private property
+   * `_isReverse`.
+   * @returns The `isReverse` property of the object, which is a boolean value.
+   */
+  get isReverse(): boolean {
+    return this._isReverse;
+  }
+
   /**
    * The function creates a new BSTNode with the given key and value and returns it.
    * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -155,8 +225,9 @@ export class BST<
     return new BST<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
+      isReverse: this._isReverse,
       ...options
     }) as TREE;
   }
@@ -170,11 +241,11 @@ export class BST<
    * value associated with a key in a key-value pair.
    * @returns either a NODE object or undefined.
    */
-  override keyValueNodeEntryRawToNodeAndValue(
+  protected override _keyValueNodeEntryRawToNodeAndValue(
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V
   ): [OptNode<NODE>, V | undefined] {
-    const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (node === null) return [undefined, undefined];
     return [node, value ?? entryValue];
   }
@@ -217,11 +288,11 @@ export class BST<
    * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
    * type `K`.
    * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
-   * the result of the `isComparable` function with the condition `this.comparator !==
+   * the result of the `isComparable` function with the condition `this._compare !==
    * this._DEFAULT_COMPARATOR`.
    */
   override isKey(key: any): key is K {
-    return isComparable(key, this.comparator !== this._DEFAULT_COMPARATOR);
+    return isComparable(key, this._extractComparable !== undefined);
   }
 
   /**
@@ -236,7 +307,7 @@ export class BST<
    * @returns a boolean value.
    */
   override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (newNode === undefined) return false;
 
     if (this._root === undefined) {
@@ -248,11 +319,11 @@ export class BST<
 
     let current = this._root;
     while (current !== undefined) {
-      if (this.comparator(current.key, newNode.key) === 0) {
+      if (this._compare(current.key, newNode.key) === 0) {
         this._replaceNode(current, newNode);
         if (this._isMapMode) this._setValue(current.key, newValue);
         return true;
-      } else if (this.comparator(current.key, newNode.key) > 0) {
+      } else if (this._compare(current.key, newNode.key) > 0) {
         if (current.left === undefined) {
           current.left = newNode;
           if (this._isMapMode) this._setValue(newNode?.key, newValue);
@@ -350,7 +421,7 @@ export class BST<
       }
 
       if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
-        return this.comparator(keyA, keyB);
+        return this._compare(keyA, keyB);
       }
       return 0;
     });
@@ -392,64 +463,114 @@ export class BST<
     return inserted;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `merge` function overrides the base class method by adding elements from another
+   * binary search tree.
+   * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
+   * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
+   */
+  override merge(anotherTree: BST<K, V, R, NODE, TREE>) {
+    this.addMany(anotherTree, [], false);
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(k + log n)
    *
-   * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-   * given keyNodeEntryRawOrPredicate and iteration type.
-   * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-   * parameter in the `getNodes` method is used to filter the nodes that will be returned. It can be a
-   * key, a node, an entry, or a custom keyNodeEntryRawOrPredicate function that determines whether a node should be
-   * included in the result.
-   * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` method is a boolean flag that
-   * determines whether to return only the first node that matches the keyNodeEntryRawOrPredicate (`true`) or all nodes
-   * that match the keyNodeEntryRawOrPredicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
-   * and
-   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
-   * `getNodes` method is used to specify the starting point for traversing the tree when searching for
-   * nodes that match a given keyNodeEntryRawOrPredicate. It represents the root node of the subtree where the search
-   * should begin. If not explicitly provided, the default value for `begin
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` method
-   * specifies the type of iteration to be performed when traversing the nodes of a binary tree. It can
-   * have two possible values:
-   * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
+   * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
+   * on specified criteria.
+   * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+   * `keyNodeEntryRawOrPredicate` parameter in the `override search` method can accept one of the
+   * following types:
+   * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
+   * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
+   * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
+   * @param {C} callback - The `callback` parameter in the `override search` function is a function
+   * that will be called on each node that matches the search criteria. It is of type `C`, which
+   * extends `NodeCallback<NODE>`. The callback function should accept a node of type `NODE` as its
+   * argument and
+   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `override search`
+   * method represents the node from which the search operation will begin. It is the starting point
+   * for searching within the tree data structure. The method ensures that the `startNode` is a valid
+   * node before proceeding with the search operation. If the `
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `override search`
+   * function determines the type of iteration to be used during the search operation. It can have two
+   * possible values:
+   * @returns The `override search` method returns an array of values that match the search criteria
+   * specified by the input parameters. The method performs a search operation on a binary tree
+   * structure based on the provided key, predicate, and other options. The search results are
+   * collected in an array and returned as the output of the method.
    */
-  override getNodes(
-    keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>,
+  override search<C extends NodeCallback<NODE>>(
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE> | Range<K>,
     onlyOne = false,
+    callback: C = this._DEFAULT_NODE_CALLBACK as C,
     startNode: BTNRep<K, V, NODE> | R = this._root,
     iterationType: IterationType = this.iterationType
-  ): NODE[] {
+  ): ReturnType<C>[] {
     if (keyNodeEntryRawOrPredicate === undefined) return [];
     if (keyNodeEntryRawOrPredicate === null) return [];
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
-    const ans: NODE[] = [];
+    let predicate: NodePredicate<NODE>;
 
+    const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+    // Set predicate based on parameter type
+    if (isRange) {
+      predicate = node => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+    } else {
+      predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+    }
+    const isToLeftByRange = (cur: NODE) => {
+      if (isRange) {
+        const range = keyNodeEntryRawOrPredicate;
+        const leftS = this.isReverse ? range.high : range.low;
+        const leftI = this.isReverse ? range.includeHigh : range.includeLow;
+        return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
+      }
+      return false;
+    };
+
+    const isToRightByRange = (cur: NODE) => {
+      if (isRange) {
+        const range = keyNodeEntryRawOrPredicate;
+        const rightS = this.isReverse ? range.low : range.high;
+        const rightI = this.isReverse ? range.includeLow : range.includeLow;
+
+        return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
+      }
+      return false;
+    };
+    const ans: ReturnType<C>[] = [];
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE) => {
-        if (callback(cur)) {
-          ans.push(cur);
+        if (predicate(cur)) {
+          ans.push(callback(cur));
           if (onlyOne) return;
         }
 
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-        if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-          const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+
+        if (isRange) {
+          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) dfs(cur.left);
+          if (this.isRealNode(cur.right) && isToRightByRange(cur)) dfs(cur.right);
+        } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
           if (
             this.isRealNode(cur.left) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) > 0
+            this._compare(cur.key, benchmarkKey) > 0
           )
             dfs(cur.left);
           if (
             this.isRealNode(cur.right) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) < 0
+            this._compare(cur.key, benchmarkKey) < 0
           )
             dfs(cur.right);
         } else {
@@ -463,24 +584,27 @@ export class BST<
       const stack = [startNode];
       while (stack.length > 0) {
         const cur = stack.pop()!;
-        if (callback(cur)) {
-          ans.push(cur);
+        if (predicate(cur)) {
+          ans.push(callback(cur));
           if (onlyOne) return ans;
         }
-        if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-          const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+        if (isRange) {
+          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) stack.push(cur.left);
+          if (this.isRealNode(cur.right) && isToRightByRange(cur)) stack.push(cur.right);
+        } else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+          const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
           if (
             this.isRealNode(cur.right) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) < 0
+            this._compare(cur.key, benchmarkKey) < 0
           )
             stack.push(cur.right);
           if (
             this.isRealNode(cur.left) &&
             benchmarkKey !== null &&
             benchmarkKey !== undefined &&
-            this.comparator(cur.key, benchmarkKey) > 0
+            this._compare(cur.key, benchmarkKey) > 0
           )
             stack.push(cur.left);
         } else {
@@ -493,6 +617,37 @@ export class BST<
     return ans;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(n)
+   *
+   * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
+   * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
+   * either a `Range` object or an array of two elements representing the range boundaries.
+   * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
+   * function that is used to process each node that is found within the specified range during the
+   * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+   * data structure.
+   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+   * function represents the node from which the search for nodes within the specified range will
+   * begin. It is the starting point for the range search operation.
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
+   * is used to specify the type of iteration to be performed during the search operation. It has a
+   * default value of `this.iterationType`, which suggests that it is likely a property of the class or
+   * object that the `rangeSearch`
+   * @returns The `rangeSearch` function is returning the result of calling the `search` method with
+   * the specified parameters.
+   */
+  rangeSearch<C extends NodeCallback<NODE>>(
+    range: Range<K> | [K, K],
+    callback: C = this._DEFAULT_NODE_CALLBACK as C,
+    startNode: BTNRep<K, V, NODE> | R = this._root,
+    iterationType: IterationType = this.iterationType
+  ) {
+    const searchRange: Range<K> = range instanceof Range ? range : new Range(range[0], range[1]);
+    return this.search(searchRange, false, callback, startNode, iterationType);
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -521,23 +676,6 @@ export class BST<
     return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? undefined;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The function `getNodeByKey` returns a node with a specific key from a tree data structure.
-   * @param {K} key - The key parameter is the value used to search for a specific node in the tree. It
-   * is typically a unique identifier or a value that can be used to determine the position of the node
-   * in the tree structure.
-   * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
-   * parameter that specifies the type of iteration to be used when searching for a node in the tree.
-   * It has a default value of `'ITERATIVE'`.
-   * @returns The method is returning a NODE object or undefined.
-   */
-  override getNodeByKey(key: K, iterationType: IterationType = this.iterationType): OptNode<NODE> {
-    return this.getNode(key, this._root, iterationType);
-  }
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -654,9 +792,9 @@ export class BST<
 
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE) => {
-        const compared = this.comparator(cur.key, targetKey);
+        const compared = this._compare(cur.key, targetKey);
         if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
-
+        // TODO here can be optimized to O(log n)
         if (this.isRealNode(cur.left)) dfs(cur.left);
         if (this.isRealNode(cur.right)) dfs(cur.right);
       };
@@ -668,7 +806,7 @@ export class BST<
       while (queue.size > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
-          const compared = this.comparator(cur.key, targetKey);
+          const compared = this._compare(cur.key, targetKey);
           if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
 
           if (this.isRealNode(cur.left)) queue.push(cur.left);
@@ -786,19 +924,26 @@ export class BST<
     return balanced;
   }
 
-  protected _DEFAULT_COMPARATOR = (a: K, b: K): number => {
+  protected _comparator: Comparator<K> = (a: K, b: K): number => {
+    if (isComparable(a) && isComparable(b)) {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
+    }
+    if (this._extractComparable) {
+      if (this._extractComparable(a) > this._extractComparable(b)) return 1;
+      if (this._extractComparable(a) < this._extractComparable(b)) return -1;
+      return 0;
+    }
     if (typeof a === 'object' || typeof b === 'object') {
       throw TypeError(
-        `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+        `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
       );
     }
-    if (a > b) return 1;
-    if (a < b) return -1;
+
     return 0;
   };
 
-  protected _comparator: Comparator<K> = this._DEFAULT_COMPARATOR;
-
   /**
    * The function returns the value of the _comparator property.
    * @returns The `_comparator` property is being returned.
@@ -807,6 +952,17 @@ export class BST<
     return this._comparator;
   }
 
+  protected _extractComparable?: (key: K) => Comparable;
+
+  /**
+   * This function returns the value of the `_extractComparable` property.
+   * @returns The method `extractComparable()` is being returned, which is a getter method for the
+   * `_extractComparable` property.
+   */
+  get extractComparable() {
+    return this._extractComparable;
+  }
+
   /**
    * The function sets the root of a tree-like structure and updates the parent property of the new
    * root.
@@ -818,4 +974,8 @@ export class BST<
     }
     this._root = v;
   }
+
+  protected _compare(a: K, b: K) {
+    return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+  }
 }

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

@@ -3,6 +3,6 @@ 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';

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

@@ -51,6 +51,59 @@ export class RedBlackTreeNode<
   }
 }
 
+/**
+ * 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,
@@ -119,7 +172,7 @@ export class RedBlackTree<
     return new RedBlackTree<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
@@ -203,7 +256,7 @@ export class RedBlackTree<
    * 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);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (!this.isRealNode(newNode)) return false;
 
     const insertStatus = this._insert(newNode);
@@ -351,7 +404,7 @@ export class RedBlackTree<
 
     while (this.isRealNode(current)) {
       parent = current;
-      const compared = this.comparator(node.key, current.key);
+      const compared = this._compare(node.key, current.key);
       if (compared < 0) {
         current = current.left ?? this.NIL;
       } else if (compared > 0) {

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -17,7 +17,7 @@ import type {
   TreeMultiMapOptions
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
-import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
+import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 
 export class TreeMultiMapNode<
   K = any,
@@ -139,7 +139,7 @@ export class TreeMultiMap<
     return new TreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
       ...options
     }) as TREE;
@@ -157,7 +157,7 @@ export class TreeMultiMap<
    * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
    * @returns either a NODE object or undefined.
    */
-  override keyValueNodeEntryRawToNodeAndValue(
+  protected override _keyValueNodeEntryRawToNodeAndValue(
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V,
     count = 1
@@ -173,8 +173,8 @@ export class TreeMultiMap<
       if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    if (this._toEntryFn) {
-      const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
       const finalValue = value ?? entryValue;
       if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
@@ -212,7 +212,7 @@ export class TreeMultiMap<
    * was successful, and false otherwise.
    */
   override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count = 1): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
     const orgCount = newNode?.count || 0;
     const isSuccessAdded = super.add(newNode, newValue);