undirected-graph-typed 1.52.8 → 1.53.0

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

@@ -20,7 +20,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
     }
     /**
      * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be an
+     * @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) {
@@ -39,7 +39,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
     }
     /**
      * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptBSTN<NODE>} v - The parameter `v` is of type `OptBSTN<NODE>`. It can either be a
+     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
      * `NODE` object or `undefined`.
      */
     set right(v) {
@@ -62,13 +62,13 @@ exports.BSTNode = BSTNode;
 class BST extends binary_tree_1.BinaryTree {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
      * added to the binary search tree during the construction of the object.
      * @param [options] - An optional object that contains additional options for the Binary Search Tree.
      * It can include a comparator function that defines the order of the elements in the tree.
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
         this._root = undefined;
         this._DEFAULT_COMPARATOR = (a, b) => {
@@ -87,8 +87,8 @@ class BST extends binary_tree_1.BinaryTree {
             if (comparator)
                 this._comparator = comparator;
         }
-        if (keysOrNodesOrEntriesOrRaws)
-            this.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws)
+            this.addMany(keysNodesEntriesOrRaws);
     }
     /**
      * The function returns the root node of a tree structure.
@@ -116,20 +116,22 @@ 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, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - A variable that can be of
-     * type R or BTNKeyOrNodeOrEntry<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
-        var _a;
-        return (_a = super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value)) !== null && _a !== void 0 ? _a : undefined;
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
+        const [node, tValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        if (node === null)
+            return [undefined, undefined];
+        return [node, tValue !== null && tValue !== void 0 ? tValue : value];
     }
     /**
      * Time Complexity: O(log n)
@@ -137,8 +139,8 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -146,19 +148,19 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
+    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
         var _a;
-        return (_a = super.ensureNode(keyOrNodeOrEntryOrRaw, iterationType)) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = super.ensureNode(keyNodeEntryOrRaw, iterationType)) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @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
      * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof BSTNode;
     }
     /**
      * The function "override isKey" checks if a key is comparable based on a given comparator.
@@ -176,18 +178,20 @@ class BST extends binary_tree_1.BinaryTree {
      * Space Complexity: O(1)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+    add(keyNodeEntryOrRaw, value) {
+        const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
             this._setRoot(newNode);
+            if (this._isMapMode)
+                this._setValue(newNode === null || newNode === void 0 ? void 0 : newNode.key, newValue);
             this._size++;
             return true;
         }
@@ -200,6 +204,8 @@ class BST extends binary_tree_1.BinaryTree {
             else if (this.comparator(current.key, newNode.key) > 0) {
                 if (current.left === undefined) {
                     current.left = newNode;
+                    if (this._isMapMode)
+                        this._setValue(newNode === null || newNode === void 0 ? void 0 : newNode.key, newValue);
                     this._size++;
                     return true;
                 }
@@ -208,6 +214,8 @@ class BST extends binary_tree_1.BinaryTree {
             else {
                 if (current.right === undefined) {
                     current.right = newNode;
+                    if (this._isMapMode)
+                        this._setValue(newNode === null || newNode === void 0 ? void 0 : newNode.key, newValue);
                     this._size++;
                     return true;
                 }
@@ -222,7 +230,7 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure and returns
      * an array indicating whether each key or node was successfully inserted.
-     * @param keysOrNodesOrEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
+     * @param keysNodesEntriesOrRaws - An iterable containing keys, nodes, entries, or raw
      * elements to be added to the data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
@@ -237,32 +245,27 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysNodesEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysOrNodesOrEntriesOrRaws) {
+            for (const kve of keysNodesEntriesOrRaws) {
                 const value = valuesIterator === null || valuesIterator === void 0 ? void 0 : valuesIterator.next().value;
-                const nn = this.add(kve, value);
-                inserted.push(nn);
+                inserted.push(this.add(kve, value));
             }
             return inserted;
         }
         const realBTNExemplars = [];
-        const isRealBTNExemplar = (kve) => {
-            if (kve === undefined || kve === null)
-                return false;
-            return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
-        };
-        for (const kve of keysOrNodesOrEntriesOrRaws) {
-            if (isRealBTNExemplar(kve))
-                realBTNExemplars.push(kve);
+        let i = 0;
+        for (const kve of keysNodesEntriesOrRaws) {
+            realBTNExemplars.push({ key: kve, value: valuesIterator === null || valuesIterator === void 0 ? void 0 : valuesIterator.next().value, orgIndex: i });
+            i++;
         }
         let sorted = [];
-        sorted = realBTNExemplars.sort((a, b) => {
+        sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
             let keyA, keyB;
             if (this.isEntry(a))
                 keyA = a[0];
@@ -293,8 +296,8 @@ class BST extends binary_tree_1.BinaryTree {
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            const newNode = this.add(arr[mid]);
-            inserted.push(newNode);
+            const { key, value, orgIndex } = arr[mid];
+            inserted[orgIndex] = this.add(key, value);
             _dfs(arr.slice(0, mid));
             _dfs(arr.slice(mid + 1));
         };
@@ -307,8 +310,8 @@ class BST extends binary_tree_1.BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const newNode = this.add(sorted[m]);
-                        inserted.push(newNode);
+                        const { key, value, orgIndex } = sorted[m];
+                        inserted[orgIndex] = this.add(key, value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -328,33 +331,33 @@ class BST extends binary_tree_1.BinaryTree {
      * Space Complexity: O(k + log n)
      *
      * The function `getNodes` in TypeScript overrides the base class method to retrieve nodes based on a
-     * given predicate and iteration type.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * 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 predicate function that determines whether a node should be
+     * 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 predicate (`true`) or all nodes
-     * that match the predicate (`false`). If `onlyOne` is set to `true`, the method will stop iterating
+     * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter in the
+     * @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 predicate. It represents the root node of the subtree where the search
+     * 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 predicate.
+     * @returns The `getNodes` method returns an array of nodes that satisfy the given keyNodeEntryRawOrPredicate.
      */
-    getNodes(predicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
-        if (predicate === undefined)
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryRawOrPredicate === undefined)
             return [];
-        if (predicate === null)
+        if (keyNodeEntryRawOrPredicate === null)
             return [];
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        startNode = this.ensureNode(startNode);
+        if (!startNode)
             return [];
-        const callback = this._ensurePredicate(predicate);
+        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -365,10 +368,17 @@ class BST extends binary_tree_1.BinaryTree {
                 }
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this.isKey(predicate)) {
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
+                if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+                    const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+                    if (this.isRealNode(cur.left) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) > 0)
                         dfs(cur.left);
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
+                    if (this.isRealNode(cur.right) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) < 0)
                         dfs(cur.right);
                 }
                 else {
@@ -378,10 +388,10 @@ class BST extends binary_tree_1.BinaryTree {
                         dfs(cur.right);
                 }
             };
-            dfs(beginRoot);
+            dfs(startNode);
         }
         else {
-            const stack = [beginRoot];
+            const stack = [startNode];
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (callback(cur)) {
@@ -389,10 +399,17 @@ class BST extends binary_tree_1.BinaryTree {
                     if (onlyOne)
                         return ans;
                 }
-                if (this.isKey(predicate)) {
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
+                if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
+                    const benchmarkKey = this._getKey(keyNodeEntryRawOrPredicate);
+                    if (this.isRealNode(cur.right) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) < 0)
                         stack.push(cur.right);
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
+                    if (this.isRealNode(cur.left) &&
+                        benchmarkKey !== null &&
+                        benchmarkKey !== undefined &&
+                        this.comparator(cur.key, benchmarkKey) > 0)
                         stack.push(cur.left);
                 }
                 else {
@@ -409,10 +426,10 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * This function retrieves a node based on a given predicate within a binary search tree structure.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
-     * parameter can be of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, `R`, or `BTNPredicate<NODE>`.
-     * @param {R | BSTNKeyOrNode<K, NODE>} beginRoot - The `beginRoot` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
+     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -420,14 +437,14 @@ class BST extends binary_tree_1.BinaryTree {
      * parameter that specifies the type of iteration to be used. It has a default value of
      * `this.iterationType`, which means it will use the iteration type defined in the class instance if
      * no value is provided when calling the method.
-     * @returns The `getNode` method is returning an optional binary search tree node (`OptBSTN<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided predicate, beginning at
-     * the specified root node (`beginRoot`) and using the specified iteration type. The method then
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<NODE>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(predicate, beginRoot = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNodes(predicate, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Time Complexity: O(log n)
@@ -453,11 +470,11 @@ class BST extends binary_tree_1.BinaryTree {
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * during the depth-first search traversal. It is an optional parameter and defaults to
-     * `this._DEFAULT_BTN_CALLBACK`. The type `C` represents the type of the callback function.
+     * `this._DEFAULT_NODE_CALLBACK`. The type `C` represents the type of the callback function.
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -465,8 +482,8 @@ class BST extends binary_tree_1.BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root, iterationType = this.iterationType) {
-        return super.dfs(callback, pattern, beginRoot, iterationType);
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType) {
+        return super.dfs(callback, pattern, startNode, iterationType);
     }
     /**
      * Time complexity: O(n)
@@ -477,7 +494,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -485,8 +502,8 @@ class BST extends binary_tree_1.BinaryTree {
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        return super.bfs(callback, beginRoot, iterationType, false);
+    bfs(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        return super.bfs(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -495,9 +512,9 @@ class BST extends binary_tree_1.BinaryTree {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -506,8 +523,8 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
-        return super.listLevels(callback, beginRoot, iterationType, false);
+    listLevels(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        return super.listLevels(callback, startNode, iterationType, false);
     }
     /**
      * Time complexity: O(n)
@@ -521,7 +538,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -530,7 +547,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._DEFAULT_BTN_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_NODE_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
         const targetNodeEnsured = this.ensureNode(targetNode);
         const ans = [];
         if (!this._root)
@@ -582,7 +599,7 @@ class BST extends binary_tree_1.BinaryTree {
      */
     perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'IN'), n = sorted.length;
-        this.clear();
+        this._clearNodes();
         if (sorted.length < 1)
             return false;
         if (iterationType === 'RECURSIVE') {
@@ -591,7 +608,10 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add([midNode.key, midNode.value]);
+                if (this._isMapMode)
+                    this.add(midNode.key);
+                else
+                    this.add([midNode.key, midNode.value]);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -607,7 +627,10 @@ class BST extends binary_tree_1.BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add([midNode.key, midNode.value]);
+                        if (this._isMapMode)
+                            this.add(midNode.key);
+                        else
+                            this.add([midNode.key, midNode.value]);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -683,7 +706,7 @@ class BST extends binary_tree_1.BinaryTree {
     /**
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {OptBSTN<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
      */
     _setRoot(v) {
         if (v) {

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNKeyOrNodeOrEntry, BTNPredicate, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested, BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BTNRep, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -26,10 +26,10 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      */
     set color(value: RBTNColor);
 }
-export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, 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> {
+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.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @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
@@ -37,7 +37,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
      * depend on the implementation
      */
-    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -71,12 +71,12 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * Space Complexity: O(1)
      *
      * The function checks if the input is an instance of the RedBlackTreeNode class.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @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
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
+    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -91,8 +91,8 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      *
      * The function adds a new node to a binary search tree and returns true if the node was successfully
      * added.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
      * @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.
@@ -100,14 +100,14 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * 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(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean;
+    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * 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.
@@ -115,7 +115,7 @@ export declare class RedBlackTree<K = any, V = any, R = BTNEntry<K, V>, NODE ext
      * objects. Each object in the array contains information about the deleted node and whether
      * balancing is needed.
      */
-    delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)