data-structure-typed 1.51.7 → 1.51.9

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

@@ -59,25 +59,24 @@ export class BSTNode extends BinaryTreeNode {
  */
 export class BST extends BinaryTree {
     /**
-     * This is the constructor function for a TypeScript class that initializes a binary search tree with
-     * optional keys or nodes or entries and options.
-     * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
-     * to initialize the binary search tree with the provided keys, nodes, or entries.
-     * @param [options] - The `options` parameter is an optional object that can contain additional
-     * configuration options for the binary search tree. It can have the following properties:
-     */
-    constructor(keysOrNodesOrEntries = [], options) {
+     * This is the constructor function for a Binary Search Tree class in TypeScript.
+     * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` 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) {
         super([], options);
         if (options) {
-            const { variant } = options;
-            if (variant)
-                this._variant = variant;
+            const { comparator } = options;
+            if (comparator)
+                this._comparator = comparator;
         }
-        this._root = undefined;
-        if (keysOrNodesOrEntries)
-            this.addMany(keysOrNodesOrEntries);
+        if (keysOrNodesOrEntriesOrRawElements)
+            this.addMany(keysOrNodesOrEntriesOrRawElements);
     }
-    _root;
+    _root = undefined;
     /**
      * The function returns the root node of a tree structure.
      * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
@@ -85,14 +84,6 @@ export class BST extends BinaryTree {
     get root() {
         return this._root;
     }
-    _variant = 'STANDARD';
-    /**
-     * The function returns the value of the _variant property.
-     * @returns The value of the `_variant` property.
-     */
-    get variant() {
-        return this._variant;
-    }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -107,110 +98,70 @@ export class BST extends BinaryTree {
     /**
      * The function creates a new binary search tree with the specified options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
-     * behavior of the `createTree` method. It is of type `Partial<BSTOptions<K>>`, which means it is a
-     * partial object of type `BSTOptions<K>`.
-     * @returns a new instance of the BST class, with the provided options merged with the default
-     * options. The returned value is casted as TREE.
+     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
+     * following properties:
+     * @returns a new instance of the BST class with the provided options.
      */
     createTree(options) {
         return new BST([], {
             iterationType: this.iterationType,
-            variant: this.variant,
+            comparator: this.comparator,
             ...options
         });
     }
     /**
-     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
-     * otherwise it returns undefined.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
-     * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
-     * @returns a node of type NODE or undefined.
-     */
-    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
-        let node;
-        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
-            return;
-        }
-        else if (this.isNode(keyOrNodeOrEntry)) {
-            node = keyOrNodeOrEntry;
-        }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            const [key, value] = keyOrNodeOrEntry;
-            if (key === undefined || key === null) {
-                return;
-            }
-            else {
-                node = this.createNode(key, value);
-            }
-        }
-        else if (!this.isNode(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, value);
-        }
-        else {
-            return;
-        }
-        return node;
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - A variable that can be of
+     * type R or KeyOrNodeOrEntry<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;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
-     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
-     * otherwise it returns the key itself.
-     * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
-     * @returns either a node object (NODE) or undefined.
-     */
-    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        if (keyOrNodeOrEntry === this.NIL)
-            return;
-        if (this.isRealNode(keyOrNodeOrEntry)) {
-            return keyOrNodeOrEntry;
-        }
-        if (this.isEntry(keyOrNodeOrEntry)) {
-            const key = keyOrNodeOrEntry[0];
-            if (key === null || key === undefined)
-                return;
-            return this.getNodeByKey(key, iterationType);
-        }
-        const key = keyOrNodeOrEntry;
-        if (key === null || key === undefined)
-            return;
-        return this.getNodeByKey(key, iterationType);
+     * The function ensures the existence of a node in a data structure and returns it, or undefined if
+     * it doesn't exist.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` 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
+     * value of `'ITERATIVE'`.
+     * @returns The method is returning either the node that was ensured or `undefined` if the node could
+     * not be ensured.
+     */
+    ensureNode(keyOrNodeOrEntryOrRawElement, iterationType = 'ITERATIVE') {
+        return super.ensureNode(keyOrNodeOrEntryOrRawElement, iterationType) ?? undefined;
     }
     /**
-     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     * The function checks if the input is an instance of the BSTNode class.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `KeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * an instance of the `BSTNode` class.
      */
-    isNode(keyOrNodeOrEntry) {
-        return keyOrNodeOrEntry instanceof BSTNode;
+    isNode(keyOrNodeOrEntryOrRawElement) {
+        return keyOrNodeOrEntryOrRawElement instanceof BSTNode;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
-     * or inserting a new node if the key is unique.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary tree.
-     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
-     * node was not added.
-     */
-    add(keyOrNodeOrEntry, value) {
-        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
+     * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
+     * `keyOrNodeOrEntryOrRawElement` can accept a value of type `R` or `KeyOrNodeOrEntry<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);
         if (newNode === undefined)
             return false;
         if (this.root === undefined) {
@@ -220,18 +171,11 @@ export class BST extends BinaryTree {
         }
         let current = this.root;
         while (current !== undefined) {
-            if (this._compare(current.key, newNode.key) === 'EQ') {
-                // if (current !== newNode) {
-                // The key value is the same but the reference is different, update the value of the existing node
+            if (this.comparator(current.key, newNode.key) === 0) {
                 this._replaceNode(current, newNode);
                 return true;
-                // } else {
-                // The key value is the same and the reference is the same, replace the entire node
-                // this._replaceNode(current, newNode);
-                //   return;
-                // }
             }
-            else if (this._compare(current.key, newNode.key) === 'GT') {
+            else if (this.comparator(current.key, newNode.key) > 0) {
                 if (current.left === undefined) {
                     current.left = newNode;
                     this._size++;
@@ -251,37 +195,38 @@ export class BST extends BinaryTree {
         return false;
     }
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(k + log n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
      *
-     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
-     * balancing the tree after each addition.
-     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
-     * the binary tree.
+     * 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
+     * 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
      * order. If not provided, undefined will be assigned as the value for each key or node.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
-     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
-     * in the order they appear in the input.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes. It has a default value of
-     * `this.iterationType`, which suggests that it is a property of the current object.
-     * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
-     */
-    addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
+     * adding the elements. If set to true, the tree will be balanced using a binary search tree
+     * algorithm. If set to false, the elements will be added without balancing the tree. The default
+     * value is true.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when adding multiple keys or nodes to the binary search
+     * tree. It can have two possible values:
+     * @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) {
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysOrNodesOrEntries) {
+            for (const kve of keysOrNodesOrEntriesOrRawElements) {
                 const value = valuesIterator?.next().value;
                 const nn = this.add(kve, value);
                 inserted.push(nn);
@@ -294,25 +239,36 @@ export class BST extends BinaryTree {
                 return false;
             return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
         };
-        for (const kve of keysOrNodesOrEntries) {
+        for (const kve of keysOrNodesOrEntriesOrRawElements) {
             isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
         }
         let sorted = [];
         sorted = realBTNExemplars.sort((a, b) => {
-            let aR, bR;
+            let keyA, keyB;
             if (this.isEntry(a))
-                aR = this.extractor(a[0]);
+                keyA = a[0];
             else if (this.isRealNode(a))
-                aR = this.extractor(a.key);
-            else
-                aR = this.extractor(a);
+                keyA = a.key;
+            else if (this.toEntryFn) {
+                keyA = this.toEntryFn(a)[0];
+            }
+            else {
+                keyA = a;
+            }
             if (this.isEntry(b))
-                bR = this.extractor(b[0]);
+                keyB = b[0];
             else if (this.isRealNode(b))
-                bR = this.extractor(b.key);
-            else
-                bR = this.extractor(b);
-            return aR - bR;
+                keyB = b.key;
+            else if (this.toEntryFn) {
+                keyB = this.toEntryFn(b)[0];
+            }
+            else {
+                keyB = b;
+            }
+            if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
+                return this.comparator(keyA, keyB);
+            }
+            return 0;
         });
         const _dfs = (arr) => {
             if (arr.length === 0)
@@ -349,32 +305,26 @@ export class BST extends BinaryTree {
         return inserted;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(k + log n)
-     * /
-  
-     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
      *
-     * The function `getNodes` returns an array of nodes that match a given identifier, using either a
-     * recursive or iterative approach.
+     * 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 nodes of the binary tree. It can be of any type that is returned by the
-     * callback function `C`.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as its
-     * argument and returns a value of type `ReturnType<C>`. The `C` type parameter represents a callback
-     * function type that extends the `BTNCallback<NODE>` type. The `BTNCallback<NODE>` type is
-     * @param [onlyOne=false] - A boolean flag indicating whether to stop searching after finding the
-     * first node that matches the identifier. If set to true, the function will return an array
-     * containing only the first matching node. If set to false (default), the function will continue
-     * searching for all nodes that match the identifier and return an array containing
-     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter represents the starting node
-     * for the traversal. It can be either a key value or a node object. If it is undefined, the
-     * traversal will start from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be
-     * performed on the binary tree. It can have two possible values:
-     * @returns The method returns an array of nodes (`NODE[]`).
+     * 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 | KeyOrNodeOrEntry<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.
      */
     getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNode(beginRoot);
@@ -394,9 +344,9 @@ export class BST extends BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._DEFAULT_CALLBACK) {
-                    if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
                         dfs(cur.left);
-                    if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
                         dfs(cur.right);
                 }
                 else {
@@ -418,9 +368,9 @@ export class BST extends BinaryTree {
                 }
                 // TODO potential bug
                 if (callback === this._DEFAULT_CALLBACK) {
-                    if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
                         stack.push(cur.right);
-                    if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 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);
@@ -445,50 +395,49 @@ export class BST extends BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-     * that you want to search for in the binary search tree. It can be of any type that is compatible
-     * with the type of nodes in the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-     * function should take a node as its parameter and return a value that can be compared to the
-     * `identifier` parameter.
+     * 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, it will be converted to a node
-     * using the `ensureNode` method. If it is not provided, the `root`
-     * @param 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 is an optional parameter and
-     * its default value is taken from the `iterationType` property of the class.
-     * @returns The method is returning a value of type `NODE | null | undefined`.
+     * 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.
      */
     getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-     * either recursive or iterative methods.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to identify the node that we want to retrieve.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when searching for a node in the binary tree. It can have two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
+     * The function `getNodeByKey` returns a node with a specific key from a tree data structure.
+     * @param {K} key - The key parameter is the value used to search for a specific node in the tree. It
+     * is typically a unique identifier or a value that can be used to determine the position of the node
+     * in the tree structure.
+     * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
+     * parameter that specifies the type of iteration to be used when searching for a node in the tree.
+     * It has a default value of `'ITERATIVE'`.
+     * @returns The method is returning a NODE object or undefined.
      */
     getNodeByKey(key, iterationType = 'ITERATIVE') {
         return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time complexity: O(n)
@@ -497,15 +446,16 @@ export class BST extends BinaryTree {
      * The function overrides the depth-first search method and returns an array of the return types of
      * 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 if not provided, a
-     * default callback function will be used.
-     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
-     * nodes are visited during the depth-first search. It can have one of the following values:
-     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
-     * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
-     * value is provided, the DFS traversal will start from the root of the tree.
-     * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
-     * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+     * 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.
+     * @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 | KeyOrNodeOrEntry<K, V, NODE>} 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
+     * type of iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
@@ -513,8 +463,8 @@ export class BST extends BinaryTree {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time complexity: O(n)
@@ -523,38 +473,38 @@ export class BST extends BinaryTree {
      * The function overrides the breadth-first search method and returns an array of the return types of
      * the callback function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * visited during the breadth-first search traversal. It is an optional parameter and if not
-     * provided, a default callback function will be used.
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
-     * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
-     * the tree is used as the starting point.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
-     * nodes are visited.
-     * @returns The method is returning an array of the return type of the callback function.
+     * 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 | KeyOrNodeOrEntry<K, V, NODE>} 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
+     * of iteration to be performed during the breadth-first search (BFS) traversal. It can have one of
+     * 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) {
         return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The function overrides the listLevels method and returns an array of arrays containing the return
-     * type of the callback function for each level of the tree.
+     * 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 tree
-     * during the level listing process.
-     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
-     * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
-     * provided, the root of the binary tree is used as the starting point.
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed on the tree. It determines the order in which the nodes are visited during the
-     * iteration.
+     * `BTNCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * tree during the iteration process.
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} 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
+     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
+     * of iteration to be performed on the tree. It can have one of the following values:
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
@@ -562,77 +512,42 @@ export class BST extends BinaryTree {
         return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `NODE`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root) {
-        let current = this.ensureNode(beginRoot);
-        if (!current)
-            return undefined;
-        if (this._variant === 'STANDARD') {
-            // For 'STANDARD', find the rightmost node
-            while (current.right !== undefined) {
-                current = current.right;
-            }
-        }
-        else {
-            // For BSTVariant.MAX, find the leftmost node
-            while (current.left !== undefined) {
-                current = current.left;
-            }
-        }
-        return current.key;
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      *
-     * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
-     * are either lesser or greater than a target node, depending on the specified comparison type.
+     * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
+     * each node that meets a certain condition based on a target node and a comparison value.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
-     * that satisfies the condition specified by the `lesserOrGreater` parameter. It takes a single
-     * parameter of type `NODE` (the node type) and returns a value of any type.
+     * that meets the condition specified by the `lesserOrGreater` parameter. It takes a single argument,
+     * which is the current node being traversed, and returns a value of any type.
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
-     * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
-     * `CP`, which is a custom type representing the comparison operator. The possible values for
-     * `lesserOrGreater` are
-     * @param {K | NODE | undefined} targetNode - The `targetNode` parameter represents the node in the
-     * binary tree that you want to traverse from. It can be specified either by its key, by the node
-     * object itself, or it can be left undefined to start the traversal from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-     * performed on the binary tree. It can have two possible values:
+     * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
+     * 0, or 1, where:
+     * @param {R | KeyOrNodeOrEntry<K, V, NODE>} 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,
+     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
+     * traversal to be performed on the binary tree. It can have two possible values:
      * @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 = 'LT', targetNode = this.root, iterationType = this.iterationType) {
-        targetNode = this.ensureNode(targetNode);
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = -1, targetNode = this.root, iterationType = this.iterationType) {
+        const targetNodeEnsured = this.ensureNode(targetNode);
         const ans = [];
-        if (!targetNode)
+        if (!targetNodeEnsured)
             return ans;
         if (!this.root)
             return ans;
-        const targetKey = targetNode.key;
+        const targetKey = targetNodeEnsured.key;
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                const compared = this._compare(cur.key, targetKey);
-                if (compared === lesserOrGreater)
+                const compared = this.comparator(cur.key, targetKey);
+                if (Math.sign(compared) === lesserOrGreater)
                     ans.push(callback(cur));
                 if (this.isRealNode(cur.left))
                     dfs(cur.left);
@@ -647,8 +562,8 @@ export class BST extends BinaryTree {
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
-                    const compared = this._compare(cur.key, targetKey);
-                    if (compared === lesserOrGreater)
+                    const compared = this.comparator(cur.key, targetKey);
+                    if (Math.sign(compared) === lesserOrGreater)
                         ans.push(callback(cur));
                     if (this.isRealNode(cur.left))
                         queue.push(cur.left);
@@ -660,18 +575,19 @@ export class BST extends BinaryTree {
         }
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      *
-     * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
-     * ensures the tree is perfectly balanced.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building a balanced binary search tree. It can have two possible
-     * values:
+     * The `perfectlyBalance` function takes an optional `iterationType` parameter and returns `true` if
+     * the binary search tree is perfectly balanced, otherwise it returns `false`.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when building a balanced binary search tree. It has a
+     * default value of `this.iterationType`, which means it will use the iteration type specified in the
+     * current instance of the class.
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
@@ -711,25 +627,19 @@ export class BST extends BinaryTree {
         }
     }
     /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
      *
-     * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
-     * to check if the AVL tree is balanced. It can have two possible values:
+     * The function `isAVLBalanced` checks if a binary tree is AVL balanced using either a recursive or
+     * iterative approach.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when checking if the AVL tree is balanced. It has a default
+     * value of `this.iterationType`, which means it will use the iteration type specified in the current
+     * instance of the AVL tree.
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType = this.iterationType) {
@@ -778,59 +688,44 @@ export class BST extends BinaryTree {
         return balanced;
     }
     /**
-     * The function sets the root property of an object and updates the parent property of the new root.
-     * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
-     * can either be an object of type `NODE` or it can be `undefined`.
+     * Time complexity: O(n)
+     * Space complexity: O(n)
      */
-    _setRoot(v) {
-        if (v) {
-            v.parent = undefined;
+    _DEFAULT_COMPARATOR = (a, b) => {
+        if (typeof a === 'object' && typeof b === 'object' && this.comparator === this._DEFAULT_COMPARATOR) {
+            throw TypeError('When comparing two object types, it is necessary to customize a [comparator] function of options parameter during the instantiation of the data structure.');
         }
-        this._root = v;
-    }
+        if (a > b)
+            return 1;
+        if (a < b)
+            return -1;
+        return 0;
+    };
     /**
-     * The function compares two values using a comparator function and returns whether the first value
-     * is greater than, less than, or equal to the second value.
-     * @param {K} a - The parameter "a" is of type K.
-     * @param {K} b - The parameter "b" in the above code represents a K.
-     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
-     * than), 'LT' (less than), or 'EQ' (equal).
-     */
-    _compare(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
-        if (compared > 0)
-            return 'GT';
-        if (compared < 0)
-            return 'LT';
-        return 'EQ';
-    }
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    _comparator = this._DEFAULT_COMPARATOR;
     /**
-     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
-     * `a` is less than `b` based on the specified variant.
-     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
-     * first value to be compared in the function.
-     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the `_lt` function.
-     * @returns a boolean value.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      */
-    _lt(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        return this.variant === 'STANDARD' ? extractedA < extractedB : extractedA > extractedB;
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
+    get comparator() {
+        return this._comparator;
     }
     /**
-     * The function compares two values using a custom extractor function and returns true if the first
-     * value is greater than the second value.
-     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
-     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the function.
-     * @returns a boolean value.
+     * 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.
      */
-    _gt(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
+    _setRoot(v) {
+        if (v) {
+            v.parent = undefined;
+        }
+        this._root = v;
     }
 }