data-structure-typed 1.52.6 → 1.52.8

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

@@ -61,21 +61,21 @@ export class BSTNode extends BinaryTreeNode {
 export class BST extends BinaryTree {
     /**
      * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` 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(keysOrNodesOrEntriesOrRawElements = [], options) {
+    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
         super([], options);
         if (options) {
             const { comparator } = options;
             if (comparator)
                 this._comparator = comparator;
         }
-        if (keysOrNodesOrEntriesOrRawElements)
-            this.addMany(keysOrNodesOrEntriesOrRawElements);
+        if (keysOrNodesOrEntriesOrRaws)
+            this.addMany(keysOrNodesOrEntriesOrRaws);
     }
     _root = undefined;
     /**
@@ -106,21 +106,22 @@ export class BST extends BinaryTree {
     createTree(options) {
         return new BST([], {
             iterationType: this.iterationType,
-            comparator: this.comparator,
+            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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * @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
      * 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(keyOrNodeOrEntryOrRawElement, value) {
-        return super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value) ?? undefined;
+    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) {
+        return super.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value) ?? undefined;
     }
     /**
      * Time Complexity: O(log n)
@@ -128,8 +129,8 @@ export class BST extends BinaryTree {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` 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
@@ -137,19 +138,27 @@ export class BST extends BinaryTree {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyOrNodeOrEntryOrRawElement, iterationType = this.iterationType) {
-        return super.ensureNode(keyOrNodeOrEntryOrRawElement, iterationType) ?? undefined;
+    ensureNode(keyOrNodeOrEntryOrRaw, iterationType = this.iterationType) {
+        return super.ensureNode(keyOrNodeOrEntryOrRaw, iterationType) ?? undefined;
     }
     /**
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @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
      * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement) {
-        return keyOrNodeOrEntryOrRawElement instanceof BSTNode;
+    isNode(keyOrNodeOrEntryOrRaw) {
+        return keyOrNodeOrEntryOrRaw instanceof BSTNode;
     }
+    /**
+     * The function "override isKey" checks if a key is comparable based on a given comparator.
+     * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
+     * type `K`.
+     * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
+     * the result of the `isComparable` function with the condition `this.comparator !==
+     * this._DEFAULT_COMPARATOR`.
+     */
     isKey(key) {
         return isComparable(key, this.comparator !== this._DEFAULT_COMPARATOR);
     }
@@ -158,22 +167,22 @@ export class BST extends 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<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(keyOrNodeOrEntryOrRawElement, value) {
-        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement, value);
+    add(keyOrNodeOrEntryOrRaw, value) {
+        const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
         if (newNode === undefined)
             return false;
-        if (this.root === undefined) {
+        if (this._root === undefined) {
             this._setRoot(newNode);
             this._size++;
             return true;
         }
-        let current = this.root;
+        let current = this._root;
         while (current !== undefined) {
             if (this.comparator(current.key, newNode.key) === 0) {
                 this._replaceNode(current, newNode);
@@ -204,7 +213,7 @@ export class BST extends 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 keysOrNodesOrEntriesOrRawElements - An iterable containing keys, nodes, entries, or raw
+     * @param keysOrNodesOrEntriesOrRaws - 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
@@ -219,14 +228,14 @@ export class BST extends BinaryTree {
      * @returns The function `addMany` returns an array of booleans indicating whether each element was
      * successfully inserted into the data structure.
      */
-    addMany(keysOrNodesOrEntriesOrRawElements, values, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysOrNodesOrEntriesOrRaws, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysOrNodesOrEntriesOrRawElements) {
+            for (const kve of keysOrNodesOrEntriesOrRaws) {
                 const value = valuesIterator?.next().value;
                 const nn = this.add(kve, value);
                 inserted.push(nn);
@@ -239,8 +248,9 @@ export class BST extends BinaryTree {
                 return false;
             return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
         };
-        for (const kve of keysOrNodesOrEntriesOrRawElements) {
-            isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
+        for (const kve of keysOrNodesOrEntriesOrRaws) {
+            if (isRealBTNExemplar(kve))
+                realBTNExemplars.push(kve);
         }
         let sorted = [];
         sorted = realBTNExemplars.sort((a, b) => {
@@ -249,8 +259,8 @@ export class BST extends BinaryTree {
                 keyA = a[0];
             else if (this.isRealNode(a))
                 keyA = a.key;
-            else if (this.toEntryFn) {
-                keyA = this.toEntryFn(a)[0];
+            else if (this._toEntryFn) {
+                keyA = this._toEntryFn(a)[0];
             }
             else {
                 keyA = a;
@@ -259,8 +269,8 @@ export class BST extends BinaryTree {
                 keyB = b[0];
             else if (this.isRealNode(b))
                 keyB = b.key;
-            else if (this.toEntryFn) {
-                keyB = this.toEntryFn(b)[0];
+            else if (this._toEntryFn) {
+                keyB = this._toEntryFn(b)[0];
             }
             else {
                 keyB = b;
@@ -308,54 +318,55 @@ export class BST extends BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
      *
-     * The `getNodes` function in TypeScript retrieves nodes from a binary tree based on a given
-     * identifier and callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the binary tree. It can be of any type that is returned by the callback
-     * function.
-     * @param {C} callback - The `callback` parameter is a function that takes a node as input and
-     * returns a value. This value is used to identify the nodes that match the given identifier. The
-     * `callback` function is optional and defaults to `this._DEFAULT_CALLBACK`.
-     * @param [onlyOne=false] - A boolean value indicating whether to return only the first matching node
-     * or all matching nodes. If set to true, only the first matching node will be returned. If set to
-     * false, all matching nodes will be returned. The default value is false.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
-     * point for the search in the binary tree. It can be either a node object, a key-value pair, or an
-     * entry object. If it is not provided, the `root` of the binary tree is used as the starting point.
-     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-     * iteration to be performed. It can have two possible values:
-     * @returns The method `getNodes` returns an array of `NODE` objects.
+     * 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`
+     * 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
+     * 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
+     * and
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` 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
+     * 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.
      */
-    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier === undefined)
+    getNodes(predicate, onlyOne = false, beginRoot = this._root, iterationType = this.iterationType) {
+        if (predicate === undefined)
             return [];
-        if (identifier === null)
+        if (predicate === null)
             return [];
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
-        callback = this._ensureCallback(identifier, callback);
+        const callback = this._ensurePredicate(predicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                const callbackResult = callback(cur);
-                if (callbackResult === identifier) {
+                if (callback(cur)) {
                     ans.push(cur);
                     if (onlyOne)
                         return;
                 }
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                // TODO potential bug
-                if (callback === this._DEFAULT_CALLBACK) {
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
+                if (this.isKey(predicate)) {
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
                         dfs(cur.left);
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
                         dfs(cur.right);
                 }
                 else {
-                    this.isRealNode(cur.left) && dfs(cur.left);
-                    this.isRealNode(cur.right) && dfs(cur.right);
+                    if (this.isRealNode(cur.left))
+                        dfs(cur.left);
+                    if (this.isRealNode(cur.right))
+                        dfs(cur.right);
                 }
             };
             dfs(beginRoot);
@@ -364,28 +375,22 @@ export class BST extends BinaryTree {
             const stack = [beginRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                const callbackResult = callback(cur);
-                if (callbackResult === identifier) {
+                if (callback(cur)) {
                     ans.push(cur);
                     if (onlyOne)
                         return ans;
                 }
-                // TODO potential bug
-                if (callback === this._DEFAULT_CALLBACK) {
-                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
+                if (this.isKey(predicate)) {
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, predicate) < 0)
                         stack.push(cur.right);
-                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, predicate) > 0)
                         stack.push(cur.left);
-                    // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
-                    // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
-                    // // @ts-ignore
-                    // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
-                    // // @ts-ignore
-                    // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
                 }
                 else {
-                    this.isRealNode(cur.right) && stack.push(cur.right);
-                    this.isRealNode(cur.left) && stack.push(cur.left);
+                    if (this.isRealNode(cur.right))
+                        stack.push(cur.right);
+                    if (this.isRealNode(cur.left))
+                        stack.push(cur.left);
                 }
             }
         }
@@ -395,25 +400,24 @@ export class BST extends BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getNode` returns the first node that matches the given identifier and callback
-     * function in a binary search tree.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value that you
-     * want to search for in the binary search tree. It can be of any type that is compatible with the
-     * type returned by the callback function.
-     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
-     * node matches the desired criteria. It should be a function that takes a node as an argument and
-     * returns a boolean value indicating whether the node matches the criteria or not. If no callback is
-     * provided, the default callback will be
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, the search will start from the node
-     * with that key. If it is a node, the search will start from that node.
-     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-     * of iteration to be performed when searching for nodes in the binary search tree. It can have one
-     * of the following values:
-     * @returns The method is returning a NODE object or undefined.
+     * 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
+     * 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.
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNode` method is a
+     * 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 first node found or `undefined` if no node is found.
      */
-    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-        return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+    getNode(predicate, beginRoot = this._root, iterationType = this.iterationType) {
+        return this.getNodes(predicate, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
      * Time Complexity: O(log n)
@@ -429,7 +433,7 @@ export class BST extends BinaryTree {
      * @returns The method is returning a NODE object or undefined.
      */
     getNodeByKey(key, iterationType = this.iterationType) {
-        return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+        return this.getNode(key, this._root, iterationType);
     }
     /**
      * Time complexity: O(n)
@@ -439,11 +443,11 @@ export class BST extends 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_CALLBACK`. The type `C` represents the type of the callback function.
+     * `this._DEFAULT_BTN_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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` 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
@@ -451,7 +455,7 @@ export class BST extends BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = this.iterationType) {
+    dfs(callback = this._DEFAULT_BTN_CALLBACK, pattern = 'IN', beginRoot = this._root, iterationType = this.iterationType) {
         return super.dfs(callback, pattern, beginRoot, iterationType);
     }
     /**
@@ -463,7 +467,7 @@ export class BST extends 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` 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
@@ -471,7 +475,7 @@ export class BST extends BinaryTree {
      * the following values:
      * @returns an array of the return type of the callback function.
      */
-    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
         return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
@@ -483,7 +487,7 @@ export class BST extends BinaryTree {
      * @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
      * tree during the iteration process.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter is the starting
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} beginRoot - The `beginRoot` 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
@@ -492,7 +496,7 @@ export class BST extends BinaryTree {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this._DEFAULT_BTN_CALLBACK, beginRoot = this._root, iterationType = this.iterationType) {
         return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
@@ -507,7 +511,7 @@ export class BST extends 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNKeyOrNodeOrEntry<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,
@@ -516,12 +520,12 @@ export class BST extends 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_CALLBACK, lesserOrGreater = -1, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_BTN_CALLBACK, lesserOrGreater = -1, targetNode = this._root, iterationType = this.iterationType) {
         const targetNodeEnsured = this.ensureNode(targetNode);
         const ans = [];
-        if (!targetNodeEnsured)
+        if (!this._root)
             return ans;
-        if (!this.root)
+        if (!targetNodeEnsured)
             return ans;
         const targetKey = targetNodeEnsured.key;
         if (iterationType === 'RECURSIVE') {
@@ -534,11 +538,11 @@ export class BST extends BinaryTree {
                 if (this.isRealNode(cur.right))
                     dfs(cur.right);
             };
-            dfs(this.root);
+            dfs(this._root);
             return ans;
         }
         else {
-            const queue = new Queue([this.root]);
+            const queue = new Queue([this._root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
@@ -615,7 +619,7 @@ export class BST extends BinaryTree {
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType = this.iterationType) {
-        if (!this.root)
+        if (!this._root)
             return true;
         let balanced = true;
         if (iterationType === 'RECURSIVE') {
@@ -627,11 +631,11 @@ export class BST extends BinaryTree {
                     balanced = false;
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            _height(this.root);
+            _height(this._root);
         }
         else {
             const stack = [];
-            let node = this.root, last = undefined;
+            let node = this._root, last = undefined;
             const depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
@@ -643,8 +647,8 @@ export class BST extends BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const left = node.left ? (depths.get(node.left) ?? -1) : -1;
-                            const right = node.right ? (depths.get(node.right) ?? -1) : -1;
+                            const left = node.left ? depths.get(node.left) : -1;
+                            const right = node.right ? depths.get(node.right) : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));

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

@@ -1,5 +1,4 @@
-import type { BinaryTreeDeleteResult, BTNCallback, BTNKeyOrNodeOrEntry, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { BTNEntry } from '../../types';
+import type { BinaryTreeDeleteResult, BTNKeyOrNodeOrEntry, BTNPredicate, CRUD, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested, BTNEntry } 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> {
@@ -30,7 +29,7 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
 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> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` 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
@@ -38,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(keysOrNodesOrEntriesOrRawElements?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K, V, R>);
+    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<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.
@@ -72,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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @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
      * an instance of the `RedBlackTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is NODE;
+    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -92,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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<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.
@@ -101,24 +100,22 @@ 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(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
+    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the delete method of a binary tree data structure, allowing for the
-     * deletion of a node and maintaining the balance of the tree.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that identifies the node to be deleted from the binary tree. It can be of any type that is
-     * returned by the callback function `C`. It can also be `null` or `undefined` if there is no node to
-     * delete.
-     * @param {C} callback - The `callback` parameter is a function that is used to determine the
-     * equality of nodes in the binary tree. It is optional and has a default value of
-     * `this._DEFAULT_CALLBACK`. The type of the `callback` parameter is `C`, which is a generic type
-     * that extends the `BTNCallback
-     * @returns an array of BinaryTreeDeleteResult<NODE> objects.
-     */
-    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<NODE>[];
+     * 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`
+     * 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>`
+     * 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>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)