queue-typed 1.53.6 → 1.53.7

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

@@ -5,9 +5,10 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparator, CP, DFSOrderPattern, IterationType, NodeCallback, NodePredicate, OptNode } from '../../types';
+import type { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, IterationType, NodeCallback, NodePredicate, OptNode } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
+import { Range } from '../../common';
 export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
     parent?: NODE;
     constructor(key: K, value?: V);
@@ -45,6 +46,54 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  * 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
+ * // Find kth smallest element
+ *     // Create a BST with some elements
+ *     const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
+ *     const sortedKeys = bst.dfs(node => node.key, 'IN');
+ *
+ *     // Helper function to find kth smallest
+ *     const findKthSmallest = (k: number): number | undefined => {
+ *       return sortedKeys[k - 1];
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findKthSmallest(1)); // 1
+ *     console.log(findKthSmallest(3)); // 4
+ *     console.log(findKthSmallest(7)); // 8
+ * @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.search(new Range(4, 12))); // [10, 12, 5, 7]
+ *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
+ *     console.log(bst.search(new Range(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]);
+ *
+ *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+ *       for (const num of arr1) {
+ *         if (arr2.indexOf(num) !== -1) {
+ *           return num;
+ *         }
+ *       }
+ *       return undefined;
+ *     }
+ *
+ *     // 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);
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findLCA(3, 10)); // 7
+ *     console.log(findLCA(5, 35)); // 15
+ *     console.log(findLCA(20, 30)); // 25
  */
 export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>> extends BinaryTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
@@ -62,6 +111,13 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
      */
     get root(): OptNode<NODE>;
+    protected _isReverse: boolean;
+    /**
+     * 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;
     /**
      * 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
@@ -118,7 +174,7 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * @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`.
      */
     isKey(key: any): key is K;
@@ -156,30 +212,45 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * successfully inserted into the data structure.
      */
     addMany(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
+    /**
+     * 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`.
+     */
+    merge(anotherTree: BST<K, V, R, NODE, TREE>): void;
     /**
      * 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.
      */
-    getNodes(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, onlyOne?: boolean, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): NODE[];
+    search<C extends NodeCallback<NODE>>(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE> | Range<K>, onlyOne?: boolean, callback?: C, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -201,20 +272,6 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * returns the first node found or `undefined` if no node is found.
      */
     getNode(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, startNode?: R | BSTNOptKeyOrNode<K, NODE>, iterationType?: IterationType): OptNode<NODE>;
-    /**
-     * 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.
-     */
-    getNodeByKey(key: K, iterationType?: IterationType): OptNode<NODE>;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -321,17 +378,24 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
-    protected _DEFAULT_COMPARATOR: (a: K, b: K) => number;
     protected _comparator: Comparator<K>;
     /**
      * The function returns the value of the _comparator property.
      * @returns The `_comparator` property is being returned.
      */
     get comparator(): Comparator<K>;
+    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(): ((key: K) => Comparable) | undefined;
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
      * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
      */
     protected _setRoot(v: OptNode<NODE>): void;
+    protected _compare(a: K, b: K): number;
 }

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

@@ -58,6 +58,54 @@ exports.BSTNode = BSTNode;
  * 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
+ * // Find kth smallest element
+ *     // Create a BST with some elements
+ *     const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
+ *     const sortedKeys = bst.dfs(node => node.key, 'IN');
+ *
+ *     // Helper function to find kth smallest
+ *     const findKthSmallest = (k: number): number | undefined => {
+ *       return sortedKeys[k - 1];
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findKthSmallest(1)); // 1
+ *     console.log(findKthSmallest(3)); // 4
+ *     console.log(findKthSmallest(7)); // 8
+ * @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.search(new Range(4, 12))); // [10, 12, 5, 7]
+ *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
+ *     console.log(bst.search(new Range(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]);
+ *
+ *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
+ *       for (const num of arr1) {
+ *         if (arr2.indexOf(num) !== -1) {
+ *           return num;
+ *         }
+ *       }
+ *       return undefined;
+ *     }
+ *
+ *     // 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);
+ *     };
+ *
+ *     // Assertions
+ *     console.log(findLCA(3, 10)); // 7
+ *     console.log(findLCA(5, 35)); // 15
+ *     console.log(findLCA(20, 30)); // 25
  */
 class BST extends binary_tree_1.BinaryTree {
     /**
@@ -71,21 +119,33 @@ class BST extends binary_tree_1.BinaryTree {
     constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
         this._root = undefined;
-        this._DEFAULT_COMPARATOR = (a, b) => {
+        this._isReverse = false;
+        this._comparator = (a, b) => {
+            if ((0, utils_1.isComparable)(a) && (0, utils_1.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.`);
+                throw TypeError(`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;
         };
-        this._comparator = this._DEFAULT_COMPARATOR;
         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);
@@ -97,6 +157,14 @@ class BST extends binary_tree_1.BinaryTree {
     get root() {
         return this._root;
     }
+    /**
+     * 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() {
+        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
@@ -116,7 +184,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns a new instance of the BST class with the provided options.
      */
     createTree(options) {
-        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
@@ -167,11 +235,11 @@ class BST extends binary_tree_1.BinaryTree {
      * @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`.
      */
     isKey(key) {
-        return (0, utils_1.isComparable)(key, this.comparator !== this._DEFAULT_COMPARATOR);
+        return (0, utils_1.isComparable)(key, this._extractComparable !== undefined);
     }
     /**
      * Time Complexity: O(log n)
@@ -197,13 +265,13 @@ class BST extends binary_tree_1.BinaryTree {
         }
         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)
@@ -290,7 +358,7 @@ class BST extends binary_tree_1.BinaryTree {
                 keyB = b;
             }
             if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
-                return this.comparator(keyA, keyB);
+                return this._compare(keyA, keyB);
             }
             return 0;
         });
@@ -328,30 +396,47 @@ class BST extends binary_tree_1.BinaryTree {
         }
         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`.
+     */
+    merge(anotherTree) {
+        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.
      */
-    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
         if (keyNodeEntryRawOrPredicate === undefined)
             return [];
         if (keyNodeEntryRawOrPredicate === null)
@@ -359,28 +444,60 @@ class BST extends binary_tree_1.BinaryTree {
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
-        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+        let predicate;
+        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) => {
+            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) => {
+            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 = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                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 {
@@ -396,22 +513,28 @@ class BST extends binary_tree_1.BinaryTree {
             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 {
@@ -448,22 +571,6 @@ class BST extends binary_tree_1.BinaryTree {
         var _a;
         return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : 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.
-     */
-    getNodeByKey(key, iterationType = this.iterationType) {
-        return this.getNode(key, this._root, iterationType);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -559,9 +666,10 @@ class BST extends binary_tree_1.BinaryTree {
         const targetKey = targetNodeEnsured.key;
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                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))
@@ -575,7 +683,7 @@ class BST extends binary_tree_1.BinaryTree {
             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))
@@ -705,6 +813,14 @@ class BST extends binary_tree_1.BinaryTree {
     get comparator() {
         return this._comparator;
     }
+    /**
+     * 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.
@@ -716,5 +832,8 @@ class BST extends binary_tree_1.BinaryTree {
         }
         this._root = v;
     }
+    _compare(a, b) {
+        return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
+    }
 }
 exports.BST = BST;

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

@@ -26,6 +26,10 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      */
     set color(value: RBTNColor);
 }
+/**
+ * 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.
+ */
 export declare 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> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.

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

@@ -34,6 +34,10 @@ class RedBlackTreeNode extends bst_1.BSTNode {
     }
 }
 exports.RedBlackTreeNode = 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.
+ */
 class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
@@ -83,7 +87,7 @@ class RedBlackTree extends bst_1.BST {
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
-        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * Time Complexity: O(1)
@@ -303,7 +307,7 @@ class RedBlackTree extends bst_1.BST {
         let parent = undefined;
         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 = (_a = current.left) !== null && _a !== void 0 ? _a : this.NIL;
             }