binary-tree-typed 1.53.7 → 1.54.0

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

@@ -19,6 +19,9 @@ const common_1 = require("../../common");
  */
 class BinaryTreeNode {
     constructor(key, value) {
+        this._height = 0;
+        this._color = 'BLACK';
+        this._count = 1;
         this.key = key;
         this.value = value;
     }
@@ -40,6 +43,24 @@ class BinaryTreeNode {
         }
         this._right = v;
     }
+    get height() {
+        return this._height;
+    }
+    set height(value) {
+        this._height = value;
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    get count() {
+        return this._count;
+    }
+    set count(value) {
+        this._count = value;
+    }
     get familyPosition() {
         const that = this;
         if (!this.parent) {
@@ -113,6 +134,9 @@ class BinaryTree extends base_1.IterableEntryBase {
         return this._toEntryFn;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new binary tree node with a specified key and optional value.
      * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
      * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
@@ -150,7 +174,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)
@@ -346,7 +370,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
@@ -1499,7 +1523,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         const newTree = this.createTree();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate.call(thisArg, value, key, index++, this)) {
+            if (predicate.call(thisArg, key, value, index++, this)) {
                 newTree.add([key, value]);
             }
         }
@@ -1509,34 +1533,29 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-     * function to each value, and returns a new tree with the updated values.
-     * @param callback - The `callback` parameter in the `map` method is a function that will be called
-     * on each entry in the tree. It takes four arguments:
-     * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-     * that specifies the value to be passed as `this` when executing the callback function. If provided,
-     * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-     * @returns The `map` method is returning a new tree with the entries modified by the provided
-     * callback function. Each entry in the original tree is passed to the callback function, and the
-     * result of the callback function is added to the new tree.
+     * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+     * entry in the original BinaryTree.
+     * @param callback - A function that will be called for each entry in the current binary tree. It
+     * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+     * arguments.
+     * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+     * tree being created during the mapping process. These options could include things like custom
+     * comparators, initial
+     * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+     * of `this` when executing the `callback` function. It allows you to set the context (value of
+     * `this`) within the callback function. If `thisArg` is provided, it will be passed
+     * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+     * the result of applying the provided `callback` function to each entry in the original tree.
      */
-    map(callback, thisArg) {
-        const newTree = this.createTree();
+    map(callback, options, thisArg) {
+        const newTree = new BinaryTree([], options);
         let index = 0;
         for (const [key, value] of this) {
-            newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
+            newTree.add(callback.call(thisArg, key, value, index++, this));
         }
         return newTree;
     }
-    // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
-    // //   const newTree = this.createTree();
-    // //   for (const [key, value] of this) {
-    // //     newTree.add(key, callback([key, value], this));
-    // //   }
-    // //   return newTree;
-    // // }
-    //
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1568,7 +1587,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (opts.isShowRedBlackNIL)
             output += `S for Sentinel Node(NIL)\n`;
         const display = (root) => {
-            const [lines, , ,] = this._displayAux(root, opts);
+            const [lines, ,] = this._displayAux(root, opts);
             let paragraph = '';
             for (const line of lines) {
                 paragraph += line + '\n';

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

@@ -5,38 +5,38 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, IterationType, NodeCallback, NodePredicate, OptNode } from '../../types';
+import { BSTNested, BSTNodeNested, BSTNOptKeyOrNode, BSTOptions, BTNRep, Comparable, Comparator, CP, DFSOrderPattern, EntryCallback, IterationType, NodeCallback, NodePredicate, OptNode, OptNodeOrNull } 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);
-    protected _left?: NODE;
+    _left?: OptNodeOrNull<NODE>;
     /**
      * The function returns the value of the `_left` property.
      * @returns The `_left` property of the current object is being returned.
      */
-    get left(): OptNode<NODE>;
+    get left(): OptNodeOrNull<NODE>;
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
      * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
      * instance of the `NODE` class or `undefined`.
      */
-    set left(v: OptNode<NODE>);
-    protected _right?: NODE;
+    set left(v: OptNodeOrNull<NODE>);
+    _right?: OptNodeOrNull<NODE>;
     /**
      * The function returns the right node of a binary tree or undefined if there is no right node.
      * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
      * `undefined`.
      */
-    get right(): OptNode<NODE>;
+    get right(): OptNodeOrNull<NODE>;
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
      * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
-    set right(v: OptNode<NODE>);
+    set right(v: OptNodeOrNull<NODE>);
 }
 /**
  * 1. Node Order: Each node's left child has a lesser value, and the right child has a greater value.
@@ -47,32 +47,48 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  * 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');
+ * // 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']
+ *     ]);
  *
- *     // Helper function to find kth smallest
- *     const findKthSmallest = (k: number): number | undefined => {
- *       return sortedKeys[k - 1];
- *     };
+ *     // Merge datasets into a single BinarySearchTree
+ *     const merged = new BST<number, string>(dataset1);
+ *     merged.addMany(dataset2);
+ *     merged.merge(dataset3);
  *
- *     // Assertions
- *     console.log(findKthSmallest(1)); // 1
- *     console.log(findKthSmallest(3)); // 4
- *     console.log(findKthSmallest(7)); // 8
+ *     // 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.search(new Range(4, 12))); // [10, 12, 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.search(new Range(15, 20))); // [15, 18]
+ *     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) {
@@ -82,20 +98,12 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  *       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> {
+export declare class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, R, MK, MV, MR, NODE, TREE> = BST<K, V, R, MK, MV, MR, NODE, BSTNested<K, V, R, MK, MV, MR, NODE>>> extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE> {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
@@ -144,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)
@@ -212,16 +220,6 @@ 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)
@@ -251,6 +249,28 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * collected in an array and returned as the output of the method.
      */
     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)
@@ -384,13 +404,13 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      * @returns The `_comparator` property is being returned.
      */
     get comparator(): Comparator<K>;
-    protected _extractComparable?: (key: K) => Comparable;
+    protected _specifyComparable?: (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.
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
      */
-    get extractComparable(): ((key: K) => Comparable) | undefined;
+    get specifyComparable(): ((key: K) => Comparable) | undefined;
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
@@ -398,4 +418,5 @@ export declare class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V
      */
     protected _setRoot(v: OptNode<NODE>): void;
     protected _compare(a: K, b: K): number;
+    map(callback: EntryCallback<K, V | undefined, [MK, MV]>, options?: BSTOptions<MK, MV, MR>, thisArg?: any): BST<MK, MV, MR>;
 }

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

@@ -4,6 +4,7 @@ exports.BST = exports.BSTNode = void 0;
 const binary_tree_1 = require("./binary-tree");
 const queue_1 = require("../queue");
 const utils_1 = require("../../utils");
+const common_1 = require("../../common");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
     constructor(key, value) {
         super(key, value);
@@ -59,32 +60,48 @@ exports.BSTNode = BSTNode;
  * 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');
+ * // 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']
+ *     ]);
  *
- *     // Helper function to find kth smallest
- *     const findKthSmallest = (k: number): number | undefined => {
- *       return sortedKeys[k - 1];
- *     };
+ *     // Merge datasets into a single BinarySearchTree
+ *     const merged = new BST<number, string>(dataset1);
+ *     merged.addMany(dataset2);
+ *     merged.merge(dataset3);
  *
- *     // Assertions
- *     console.log(findKthSmallest(1)); // 1
- *     console.log(findKthSmallest(3)); // 4
- *     console.log(findKthSmallest(7)); // 8
+ *     // 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.search(new Range(4, 12))); // [10, 12, 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.search(new Range(15, 20))); // [15, 18]
+ *     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) {
@@ -94,14 +111,6 @@ exports.BSTNode = BSTNode;
  *       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
@@ -128,22 +137,22 @@ class BST extends binary_tree_1.BinaryTree {
                     return -1;
                 return 0;
             }
-            if (this._extractComparable) {
-                if (this._extractComparable(a) > this._extractComparable(b))
+            if (this._specifyComparable) {
+                if (this._specifyComparable(a) > this._specifyComparable(b))
                     return 1;
-                if (this._extractComparable(a) < this._extractComparable(b))
+                if (this._specifyComparable(a) < this._specifyComparable(b))
                     return -1;
                 return 0;
             }
             if (typeof a === 'object' || typeof b === 'object') {
-                throw TypeError(`When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`);
+                throw TypeError(`When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`);
             }
             return 0;
         };
         if (options) {
-            const { extractComparable, isReverse } = options;
-            if (typeof extractComparable === 'function')
-                this._extractComparable = extractComparable;
+            const { specifyComparable, isReverse } = options;
+            if (typeof specifyComparable === 'function')
+                this._specifyComparable = specifyComparable;
             if (isReverse !== undefined)
                 this._isReverse = isReverse;
         }
@@ -184,7 +193,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, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, 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.
@@ -195,8 +204,8 @@ class BST extends binary_tree_1.BinaryTree {
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-        const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+        const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (node === null)
             return [undefined, undefined];
         return [node, value !== null && value !== void 0 ? value : entryValue];
@@ -239,7 +248,7 @@ class BST extends binary_tree_1.BinaryTree {
      * this._DEFAULT_COMPARATOR`.
      */
     isKey(key) {
-        return (0, utils_1.isComparable)(key, this._extractComparable !== undefined);
+        return (0, utils_1.isComparable)(key, this._specifyComparable !== undefined);
     }
     /**
      * Time Complexity: O(log n)
@@ -253,7 +262,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns a boolean value.
      */
     add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
@@ -279,7 +288,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.left;
+                if (current.left !== null)
+                    current = current.left;
             }
             else {
                 if (current.right === undefined) {
@@ -289,7 +299,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.right;
+                if (current.right !== null)
+                    current = current.right;
             }
         }
         return false;
@@ -396,18 +407,6 @@ 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)
@@ -547,6 +546,31 @@ class BST extends binary_tree_1.BinaryTree {
         }
         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(range, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        const searchRange = range instanceof common_1.Range ? range : new common_1.Range(range[0], range[1]);
+        return this.search(searchRange, false, callback, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -783,7 +807,8 @@ class BST extends binary_tree_1.BinaryTree {
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
-                    node = node.left;
+                    if (node.left !== null)
+                        node = node.left;
                 }
                 else {
                     node = stack[stack.length - 1];
@@ -814,12 +839,12 @@ class BST extends binary_tree_1.BinaryTree {
         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.
+     * This function returns the value of the `_specifyComparable` property.
+     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+     * `_specifyComparable` property.
      */
-    get extractComparable() {
-        return this._extractComparable;
+    get specifyComparable() {
+        return this._specifyComparable;
     }
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
@@ -835,5 +860,13 @@ class BST extends binary_tree_1.BinaryTree {
     _compare(a, b) {
         return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }
+    map(callback, options, thisArg) {
+        const newTree = new BST([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
 }
 exports.BST = BST;

package/dist/data-structures/binary-tree/index.d.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/dist/data-structures/binary-tree/index.js

@@ -19,6 +19,6 @@ __exportStar(require("./bst"), exports);
 __exportStar(require("./binary-indexed-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree"), exports);
-__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./red-black-tree"), exports);
 __exportStar(require("./avl-tree-multi-map"), exports);
 __exportStar(require("./tree-multi-map"), exports);