doubly-linked-list-typed 1.53.6 → 1.53.8

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

@@ -11,7 +11,7 @@ exports.BinaryTree = exports.BinaryTreeNode = void 0;
 const utils_1 = require("../../utils");
 const queue_1 = require("../queue");
 const base_1 = require("../base");
-const constants_1 = require("../../constants");
+const common_1 = require("../../common");
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -150,7 +150,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
      * value.
      */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
         if (keyNodeEntryOrRaw === undefined)
             return [undefined, undefined];
         if (keyNodeEntryOrRaw === null)
@@ -166,17 +166,14 @@ class BinaryTree extends base_1.IterableEntryBase {
             const finalValue = value !== null && value !== void 0 ? value : entryValue;
             return [this.createNode(key, finalValue), finalValue];
         }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value), value];
         if (this.isRaw(keyNodeEntryOrRaw)) {
-            if (this._toEntryFn) {
-                const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-                const finalValue = value !== null && value !== void 0 ? value : entryValue;
-                if (this.isKey(key))
-                    return [this.createNode(key, finalValue), finalValue];
-            }
-            return [undefined, undefined];
+            const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
+            const finalValue = value !== null && value !== void 0 ? value : entryValue;
+            if (this.isKey(key))
+                return [this.createNode(key, finalValue), finalValue];
         }
+        if (this.isKey(keyNodeEntryOrRaw))
+            return [this.createNode(keyNodeEntryOrRaw, value), value];
         return [undefined, undefined];
     }
     /**
@@ -209,15 +206,15 @@ class BinaryTree extends base_1.IterableEntryBase {
                 return null;
             if (key === undefined)
                 return;
-            return this.getNodeByKey(key, iterationType);
+            return this.getNode(key, this._root, iterationType);
         }
         if (this._toEntryFn) {
             const [key] = this._toEntryFn(keyNodeEntryOrRaw);
             if (this.isKey(key))
-                return this.getNodeByKey(key);
+                return this.getNode(key);
         }
         if (this.isKey(keyNodeEntryOrRaw))
-            return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
+            return this.getNode(keyNodeEntryOrRaw, this._root, iterationType);
         return;
     }
     /**
@@ -234,8 +231,15 @@ class BinaryTree extends base_1.IterableEntryBase {
     isNode(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw instanceof BinaryTreeNode;
     }
+    /**
+     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
+     * checking if it is an object. If the parameter is an object, the function will return `true`,
+     * indicating that it is of type `R`.
+     */
     isRaw(keyNodeEntryOrRaw) {
-        return typeof keyNodeEntryOrRaw === 'object';
+        return this._toEntryFn !== undefined && typeof keyNodeEntryOrRaw === 'object';
     }
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
@@ -274,6 +278,9 @@ class BinaryTree extends base_1.IterableEntryBase {
     isNIL(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw === this._NIL;
     }
+    isRange(keyNodeEntryRawOrPredicate) {
+        return keyNodeEntryRawOrPredicate instanceof common_1.Range;
+    }
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
@@ -339,7 +346,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * key was found and the node was replaced instead of inserted.
      */
     add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         // If the tree is empty, directly set the new node as the root node
@@ -429,6 +436,17 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return inserted;
     }
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
+     * elements from the other tree.
+     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     */
+    merge(anotherTree) {
+        this.addMany(anotherTree, []);
+    }
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -511,24 +529,27 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
      *
-     * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
-     * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - The `getNodes` function you provided takes several parameters:
-     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
-     * determines whether to return only the first node that matches the criteria specified by the
-     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
-     * `getNodes` function is used to specify the starting point for traversing the binary tree. It
-     * represents the root node of the binary tree or the node from which the traversal should begin. If
-     * not provided, the default value is set to `this._root
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
-     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
-     * can have two possible values:
-     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
-     * based on the input parameters and the iteration type specified.
+     * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
+     * structure based on a given predicate or key, with options to return multiple results or just one.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` parameter in the `search` function can accept three types of values:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function 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
+     * @param {C} callback - The `callback` parameter in the `search` function is a callback function
+     * that will be called on each node that matches the search criteria. It is of type `C`, which
+     * extends `NodeCallback<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `search` function is
+     * used to specify the node from which the search operation should begin. It represents the starting
+     * point in the binary tree where the search will be performed. If no specific `startNode` is
+     * provided, the search operation will start from the root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
+     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
+     * two possible values:
+     * @returns The `search` function returns an array of values that match the provided criteria based
+     * on the search algorithm implemented within the function.
      */
-    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)
@@ -536,12 +557,12 @@ class BinaryTree extends base_1.IterableEntryBase {
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
-        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+        const predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                if (callback(cur)) {
-                    ans.push(cur);
+                if (predicate(cur)) {
+                    ans.push(callback(cur));
                     if (onlyOne)
                         return;
                 }
@@ -559,8 +580,8 @@ class BinaryTree extends base_1.IterableEntryBase {
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (this.isRealNode(cur)) {
-                    if (callback(cur)) {
-                        ans.push(cur);
+                    if (predicate(cur)) {
+                        ans.push(callback(cur));
                         if (onlyOne)
                             return ans;
                     }
@@ -573,6 +594,30 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return ans;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(k + log n)
+     *
+     * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
+     * or predicate, with options for recursive or iterative traversal.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `getNodes` function you provided takes several parameters:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
+     * determines whether to return only the first node that matches the criteria specified by the
+     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * `getNodes` function is used to specify the starting point for traversing the binary tree. It
+     * represents the root node of the binary tree or the node from which the traversal should begin. If
+     * not provided, the default value is set to `this._root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
+     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
+     * can have two possible values:
+     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
+     * based on the input parameters and the iteration type specified.
+     */
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+        return this.search(keyNodeEntryRawOrPredicate, onlyOne, node => node, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -595,23 +640,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
-     * @param {K} key - The `key` parameter is the value used to search for a specific node in a data
-     * structure.
-     * @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
-     * specifies how the tree nodes should be traversed when searching for a node with the given key. It
-     * is an optional parameter with a default value of `this.iterationType`.
-     * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptNodeOrNull<NODE>`).
-     */
-    getNodeByKey(key, iterationType = this.iterationType) {
-        return this.getNode(key, this._root, iterationType);
+        return (_a = this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Time Complexity: O(n)
@@ -638,7 +667,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
         if (this._isMapMode) {
-            const key = this._getKey(keyNodeEntryRawOrPredicate);
+            const key = this._extractKey(keyNodeEntryRawOrPredicate);
             if (key === null || key === undefined)
                 return;
             return this._store.get(key);
@@ -667,7 +696,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Otherwise, it returns `false`.
      */
     has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType).length > 0;
+        return this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
@@ -926,7 +955,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot(callback = this._DEFAULT_NODE_CALLBACK, beginNode, isReverse = true) {
+    getPathToRoot(beginNode, callback = this._DEFAULT_NODE_CALLBACK, isReverse = false) {
         const result = [];
         let beginNodeEnsured = this.ensureNode(beginNode);
         if (!beginNodeEnsured)
@@ -1009,7 +1038,6 @@ class BinaryTree extends base_1.IterableEntryBase {
     getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
         if (this.isNIL(startNode))
             return callback(undefined);
-        // TODO support get right most by passing key in
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return callback(startNode);
@@ -1655,20 +1683,20 @@ class BinaryTree extends base_1.IterableEntryBase {
             dfs(startNode);
         }
         else {
-            const stack = [{ opt: constants_1.DFSOperation.VISIT, node: startNode }];
+            const stack = [{ opt: common_1.DFSOperation.VISIT, node: startNode }];
             const pushLeft = (cur) => {
                 var _a;
                 if (shouldVisitLeft(cur.node))
-                    stack.push({ opt: constants_1.DFSOperation.VISIT, node: (_a = cur.node) === null || _a === void 0 ? void 0 : _a.left });
+                    stack.push({ opt: common_1.DFSOperation.VISIT, node: (_a = cur.node) === null || _a === void 0 ? void 0 : _a.left });
             };
             const pushRight = (cur) => {
                 var _a;
                 if (shouldVisitRight(cur.node))
-                    stack.push({ opt: constants_1.DFSOperation.VISIT, node: (_a = cur.node) === null || _a === void 0 ? void 0 : _a.right });
+                    stack.push({ opt: common_1.DFSOperation.VISIT, node: (_a = cur.node) === null || _a === void 0 ? void 0 : _a.right });
             };
             const pushRoot = (cur) => {
                 if (shouldVisitRoot(cur.node))
-                    stack.push({ opt: constants_1.DFSOperation.PROCESS, node: cur.node });
+                    stack.push({ opt: common_1.DFSOperation.PROCESS, node: cur.node });
             };
             while (stack.length > 0) {
                 const cur = stack.pop();
@@ -1676,7 +1704,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     continue;
                 if (!shouldVisitRoot(cur.node))
                     continue;
-                if (cur.opt === constants_1.DFSOperation.PROCESS) {
+                if (cur.opt === common_1.DFSOperation.PROCESS) {
                     if (shouldProcessRoot(cur.node))
                         ans.push(callback(cur.node));
                 }
@@ -1948,16 +1976,16 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
      * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    _getKey(keyNodeEntryOrRaw) {
+    _extractKey(keyNodeEntryOrRaw) {
         if (keyNodeEntryOrRaw === null)
             return null;
         if (keyNodeEntryOrRaw === undefined)
@@ -1999,6 +2027,9 @@ class BinaryTree extends base_1.IterableEntryBase {
         return this._store.set(key, value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearNodes function sets the root node to undefined and resets the size to 0.
      */
     _clearNodes() {
@@ -2006,6 +2037,9 @@ class BinaryTree extends base_1.IterableEntryBase {
         this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearValues function clears all values stored in the _store object.
      */
     _clearValues() {

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,62 @@ 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
+ * // 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 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 +119,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
@@ -88,7 +152,7 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): [OptNode<NODE>, V | undefined];
+    protected _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): [OptNode<NODE>, V | undefined];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -118,7 +182,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 +220,67 @@ 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(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, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -201,20 +302,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 +408,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;
 }