red-black-tree-typed 1.53.7 → 1.54.1

package/dist/data-structures/binary-tree/{rb-tree.js → red-black-tree.js}

@@ -4,50 +4,106 @@ exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const bst_1 = require("./bst");
 class RedBlackTreeNode extends bst_1.BSTNode {
     /**
-     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
-     * color.
-     * @param {K} key - The key parameter is of type K and represents the key of the node in the
-     * Red-Black Tree.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
-     * creating a new instance of the Red-Black Tree Node.
-     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-     * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
+     * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
+     * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
+     * Red-Black Tree data structure.
+     * @param {V} [value] - The `value` parameter in the constructor is an optional parameter of type
+     * `V`. It represents the value associated with the key in the data structure being constructed.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter in the constructor is used to specify the
+     * color of the node in a Red-Black Tree. It has a default value of 'BLACK' if not provided
+     * explicitly.
      */
     constructor(key, value, color = 'BLACK') {
         super(key, value);
+        this.parent = undefined;
+        this._left = undefined;
+        this._right = undefined;
         this._color = color;
     }
-    /**
-     * The function returns the color value of a variable.
-     * @returns The color value stored in the private variable `_color`.
-     */
-    get color() {
-        return this._color;
+    get left() {
+        return this._left;
     }
-    /**
-     * The function sets the color property to the specified value.
-     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-     */
-    set color(value) {
-        this._color = value;
+    set left(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._left = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._right = v;
     }
 }
 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.
+ * @example
+ * // Find elements in a range
+ *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
+ *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
+ *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ * @example
+ * // using Red-Black Tree as a price-based index for stock data
+ *     // Define the structure of individual stock records
+ *     interface StockRecord {
+ *       price: number; // Stock price (key for indexing)
+ *       symbol: string; // Stock ticker symbol
+ *       volume: number; // Trade volume
+ *     }
+ *
+ *     // Simulate stock market data as it might come from an external feed
+ *     const marketStockData: StockRecord[] = [
+ *       { price: 142.5, symbol: 'AAPL', volume: 1000000 },
+ *       { price: 335.2, symbol: 'MSFT', volume: 800000 },
+ *       { price: 3285.04, symbol: 'AMZN', volume: 500000 },
+ *       { price: 267.98, symbol: 'META', volume: 750000 },
+ *       { price: 234.57, symbol: 'GOOGL', volume: 900000 }
+ *     ];
+ *
+ *     // Extend the stock record type to include metadata for database usage
+ *     type StockTableRecord = StockRecord & { lastUpdated: Date };
+ *
+ *     // Create a Red-Black Tree to index stock records by price
+ *     // Simulates a database index with stock price as the key for quick lookups
+ *     const priceIndex = new RedBlackTree<number, StockTableRecord, StockRecord>(marketStockData, {
+ *       toEntryFn: stockRecord => [
+ *         stockRecord.price, // Use stock price as the key
+ *         {
+ *           ...stockRecord,
+ *           lastUpdated: new Date() // Add a timestamp for when the record was indexed
+ *         }
+ *       ]
+ *     });
+ *
+ *     // Query the stock with the highest price
+ *     const highestPricedStock = priceIndex.getRightMost();
+ *     console.log(priceIndex.get(highestPricedStock)?.symbol); // 'AMZN' // Amazon has the highest price
+ *
+ *     // Query stocks within a specific price range (200 to 400)
+ *     const stocksInRange = priceIndex.rangeSearch(
+ *       [200, 400], // Price range
+ *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
+ *     );
+ *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
  */
 class RedBlackTree extends bst_1.BST {
     /**
-     * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-     * initialize the RBTree with the provided elements.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor. It is of type `RBTreeOptions<K, V, R>`. This object can contain various options for
-     * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
-     * depend on the implementation
+     * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
+     * raw data.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+     * is used to initialize the Red-Black Tree with keys, nodes, entries, or
+     * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
+     * V, R>`. It is an optional parameter that allows you to specify additional options for the
+     * RedBlackTree class. These options could include configuration settings, behavior customization, or
+     * any other parameters that are specific to
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
@@ -56,14 +112,13 @@ class RedBlackTree extends bst_1.BST {
             this.addMany(keysNodesEntriesOrRaws);
         }
     }
-    /**
-     * The function returns the root node of a tree or undefined if there is no root.
-     * @returns The root node of the tree structure, or undefined if there is no root node.
-     */
     get root() {
         return this._root;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key value of the node being created. It is of
      * type K, which is a generic type that can be replaced with any specific type when using the
@@ -81,62 +136,30 @@ class RedBlackTree extends bst_1.BST {
         return new RedBlackTreeNode(key, this._isMapMode ? undefined : value, color);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new Red-Black Tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that contains additional
      * configuration options for creating the Red-Black Tree. It has the following properties:
      * @returns a new instance of a RedBlackTree object.
      */
     createTree(options) {
-        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn }, options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-        return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
+    isNode(keyNodeOrEntry) {
+        return keyNodeOrEntry instanceof RedBlackTreeNode;
     }
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  */
-    //
-    // /**
-    //  * Time Complexity: O(1)
-    //  * Space Complexity: O(1)
-    //  *
-    //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
-    //  * valid, otherwise it returns undefined.
-    //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
-    //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
-    //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
-    //  */
-    // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
-    //
-    //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
-    //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
-    //
-    //   if (this._toEntryFn) {
-    //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
-    //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
-    //   }
-    //
-    //   if (this.isEntry(keyNodeEntryOrRaw)) {
-    //     const [key, value] = keyNodeEntryOrRaw;
-    //     if (key === undefined || key === null) return;
-    //     else return  this.createNode(key, value, 'RED');
-    //   }
-    //
-    //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
-    //
-    //   return ;
-    // }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -150,12 +173,12 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key in the data structure. It represents the value that you want to add or update in the data
      * structure.
@@ -163,8 +186,8 @@ class RedBlackTree extends bst_1.BST {
      * the method returns true. If the node already exists and its value is updated, the method also
      * returns true. If the node cannot be added or updated, the method returns false.
      */
-    add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+        const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
@@ -190,35 +213,37 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the delete method in a binary tree data structure to remove a node based on
      * a given predicate and maintain the binary search tree properties.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method is used to specify the condition or key based on which a
      * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
      * function that determines which node(s) should be deleted.
-     * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<NODE>`
+     * @returns The `override delete` method is returning an array of `BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>`
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(keyNodeEntryOrRaw) {
-        if (keyNodeEntryOrRaw === null)
+    delete(keyNodeOrEntry) {
+        if (keyNodeOrEntry === null)
             return [];
         const results = [];
         let nodeToDelete;
-        if (this._isPredicate(keyNodeEntryOrRaw))
-            nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+        if (this._isPredicate(keyNodeOrEntry))
+            nodeToDelete = this.getNode(keyNodeOrEntry);
         else
-            nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
+            nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
         if (!nodeToDelete) {
             return results;
         }
         let originalColor = nodeToDelete.color;
         let replacementNode;
         if (!this.isRealNode(nodeToDelete.left)) {
-            replacementNode = nodeToDelete.right;
-            this._transplant(nodeToDelete, nodeToDelete.right);
+            if (nodeToDelete.right !== null) {
+                replacementNode = nodeToDelete.right;
+                this._transplant(nodeToDelete, nodeToDelete.right);
+            }
         }
         else if (!this.isRealNode(nodeToDelete.right)) {
             replacementNode = nodeToDelete.left;
@@ -228,15 +253,18 @@ class RedBlackTree extends bst_1.BST {
             const successor = this.getLeftMost(node => node, nodeToDelete.right);
             if (successor) {
                 originalColor = successor.color;
-                replacementNode = successor.right;
+                if (successor.right !== null)
+                    replacementNode = successor.right;
                 if (successor.parent === nodeToDelete) {
                     if (this.isRealNode(replacementNode)) {
                         replacementNode.parent = successor;
                     }
                 }
                 else {
-                    this._transplant(successor, successor.right);
-                    successor.right = nodeToDelete.right;
+                    if (successor.right !== null) {
+                        this._transplant(successor, successor.right);
+                        successor.right = nodeToDelete.right;
+                    }
                     if (this.isRealNode(successor.right)) {
                         successor.right.parent = successor;
                     }
@@ -259,13 +287,54 @@ class RedBlackTree extends bst_1.BST {
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
         return results;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+     * applying a callback to each entry in the original tree.
+     * @param callback - A function that will be called for each entry in the tree, with parameters
+     * representing the key, value, index, and the tree itself. It should return an entry for the new
+     * tree.
+     * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+     * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+     * Tree that will be created during the mapping process. These options could include things like
+     * custom comparators
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+     * the value of `this` when executing the `callback` function. It allows you to set the context
+     * (value of `this`) for the callback function. This can be useful when you want to access properties
+     * or
+     * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+     * provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new RedBlackTree([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this._clone(cloned);
+        return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {NODE | undefined} v - v is a parameter of type NODE or undefined.
+     * @param {RedBlackTreeNode<K, V> | undefined} v - v is a parameter of type RedBlackTreeNode<K, V> or undefined.
      */
     _setRoot(v) {
         if (v) {
@@ -278,9 +347,9 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+     * @param {RedBlackTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
      * the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is of type `NODE`, which represents a node in a
+     * @param {RedBlackTreeNode<K, V>} newNode - The `newNode` parameter is of type `RedBlackTreeNode<K, V>`, which represents a node in a
      * data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, with the `oldNode` and `newNode` parameters.
@@ -291,11 +360,11 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `_insert` function inserts a node into a binary search tree and performs necessary fix-ups to
      * maintain the red-black tree properties.
-     * @param {NODE} node - The `node` parameter represents the node that needs to be inserted into the
+     * @param {RedBlackTreeNode<K, V>} node - The `node` parameter represents the node that needs to be inserted into the
      * binary search tree.
      * @returns a string value indicating the result of the insertion operation. It can return either
      * 'UPDATED' if the node with the same key already exists and was updated, or 'CREATED' if a new node
@@ -323,7 +392,7 @@ class RedBlackTree extends bst_1.BST {
         if (!parent) {
             this._setRoot(node);
         }
-        else if (node.key < parent.key) {
+        else if (this._compare(node.key, parent.key) < 0) {
             parent.left = node;
         }
         else {
@@ -340,9 +409,9 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function `_transplant` is used to replace a node `u` with another node `v` in a binary tree.
-     * @param {NODE} u - The parameter "u" represents a node in a binary tree.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`, which means it can
-     * either be a `NODE` object or `undefined`.
+     * @param {RedBlackTreeNode<K, V>} u - The parameter "u" represents a node in a binary tree.
+     * @param {RedBlackTreeNode<K, V> | undefined} v - The parameter `v` is of type `RedBlackTreeNode<K, V> | undefined`, which means it can
+     * either be a `RedBlackTreeNode<K, V>` object or `undefined`.
      */
     _transplant(u, v) {
         if (!u.parent) {
@@ -363,11 +432,11 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The `_insertFixup` function is used to fix the Red-Black Tree after inserting a new node.
-     * @param {NODE | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
+     * @param {RedBlackTreeNode<K, V> | undefined} z - The parameter `z` represents a node in the Red-Black Tree data
      * structure. It can either be a valid node or `undefined`.
      */
     _insertFixup(z) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         // Continue fixing the tree as long as the parent of z is red
         while (((_a = z === null || z === void 0 ? void 0 : z.parent) === null || _a === void 0 ? void 0 : _a.color) === 'RED') {
             // Check if the parent of z is the left child of its parent
@@ -401,7 +470,7 @@ class RedBlackTree extends bst_1.BST {
             else {
                 // Symmetric case for the right child (left and right exchanged)
                 // Follow the same logic as above with left and right exchanged
-                const y = (_d = (_c = z === null || z === void 0 ? void 0 : z.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.left;
+                const y = (_e = (_d = (_c = z === null || z === void 0 ? void 0 : z.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.left) !== null && _e !== void 0 ? _e : undefined;
                 if ((y === null || y === void 0 ? void 0 : y.color) === 'RED') {
                     z.parent.color = 'BLACK';
                     y.color = 'BLACK';
@@ -431,7 +500,7 @@ class RedBlackTree extends bst_1.BST {
      *
      * The `_deleteFixup` function is used to fix the red-black tree after a node deletion by adjusting
      * the colors and performing rotations.
-     * @param {NODE | undefined} node - The `node` parameter represents a node in a binary tree. It can
+     * @param {RedBlackTreeNode<K, V> | undefined} node - The `node` parameter represents a node in a binary tree. It can
      * be either a valid node object or `undefined`.
      * @returns The function does not return any value. It has a return type of `void`, which means it
      * does not return anything.
@@ -517,7 +586,7 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The `_leftRotate` function performs a left rotation on a given node in a binary tree.
-     * @param {NODE | undefined} x - The parameter `x` is of type `NODE | undefined`. It represents a
+     * @param {RedBlackTreeNode<K, V> | undefined} x - The parameter `x` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
      * node in a binary tree or `undefined` if there is no node.
      * @returns void, which means it does not return any value.
      */
@@ -548,7 +617,7 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The `_rightRotate` function performs a right rotation on a given node in a binary tree.
-     * @param {NODE | undefined} y - The parameter `y` is of type `NODE | undefined`. It represents a
+     * @param {RedBlackTreeNode<K, V> | undefined} y - The parameter `y` is of type `RedBlackTreeNode<K, V> | undefined`. It represents a
      * node in a binary tree or `undefined` if there is no node.
      * @returns void, which means it does not return any value.
      */