linked-list-typed 1.54.2 → 2.0.0

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

@@ -92,13 +92,75 @@ exports.BinaryTreeNode = BinaryTreeNode;
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
+ * @example
+ * // determine loan approval using a decision tree
+ *     // Decision tree structure
+ *     const loanDecisionTree = new BinaryTree<string>(
+ *       ['stableIncome', 'goodCredit', 'Rejected', 'Approved', 'Rejected'],
+ *       { isDuplicate: true }
+ *     );
+ *
+ *     function determineLoanApproval(
+ *       node?: BinaryTreeNode<string> | null,
+ *       conditions?: { [key: string]: boolean }
+ *     ): string {
+ *       if (!node) throw new Error('Invalid node');
+ *
+ *       // If it's a leaf node, return the decision result
+ *       if (!node.left && !node.right) return node.key;
+ *
+ *       // Check if a valid condition exists for the current node's key
+ *       return conditions?.[node.key]
+ *         ? determineLoanApproval(node.left, conditions)
+ *         : determineLoanApproval(node.right, conditions);
+ *     }
+ *
+ *     // Test case 1: Stable income and good credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })); // 'Approved'
+ *
+ *     // Test case 2: Stable income but poor credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })); // 'Rejected'
+ *
+ *     // Test case 3: No stable income
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })); // 'Rejected'
+ *
+ *     // Test case 4: No stable income and poor credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })); // 'Rejected'
+ * @example
+ * // evaluate the arithmetic expression represented by the binary tree
+ *     const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
+ *
+ *     function evaluate(node?: BinaryTreeNode<number | string> | null): number {
+ *       if (!node) return 0;
+ *
+ *       if (typeof node.key === 'number') return node.key;
+ *
+ *       const leftValue = evaluate(node.left); // Evaluate the left subtree
+ *       const rightValue = evaluate(node.right); // Evaluate the right subtree
+ *
+ *       // Perform the operation based on the current node's operator
+ *       switch (node.key) {
+ *         case '+':
+ *           return leftValue + rightValue;
+ *         case '-':
+ *           return leftValue - rightValue;
+ *         case '*':
+ *           return leftValue * rightValue;
+ *         case '/':
+ *           return rightValue !== 0 ? leftValue / rightValue : 0; // Handle division by zero
+ *         default:
+ *           throw new Error(`Unsupported operator: ${node.key}`);
+ *       }
+ *     }
+ *
+ *     console.log(evaluate(expressionTree.root)); // -27
  */
 class BinaryTree extends base_1.IterableEntryBase {
     /**
      * This TypeScript constructor function initializes a binary tree with optional options and adds
      * elements based on the provided input.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-     * iterable that can contain either objects of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+     * iterable that can contain either objects of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
      * is used to initialize the binary tree with keys, nodes, entries, or raw data.
      * @param [options] - The `options` parameter in the constructor is an optional object that can
      * contain the following properties:
@@ -107,16 +169,19 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = 'ITERATIVE';
         this._isMapMode = true;
+        this._isDuplicate = false;
         this._store = new Map();
         this._size = 0;
         this._NIL = new BinaryTreeNode(NaN);
         this._DEFAULT_NODE_CALLBACK = (node) => (node ? node.key : undefined);
         if (options) {
-            const { iterationType, toEntryFn, isMapMode } = options;
+            const { iterationType, toEntryFn, isMapMode, isDuplicate } = options;
             if (iterationType)
                 this.iterationType = iterationType;
             if (isMapMode !== undefined)
                 this._isMapMode = isMapMode;
+            if (isDuplicate !== undefined)
+                this._isDuplicate = isDuplicate;
             if (typeof toEntryFn === 'function')
                 this._toEntryFn = toEntryFn;
             else if (toEntryFn)
@@ -128,6 +193,9 @@ class BinaryTree extends base_1.IterableEntryBase {
     get isMapMode() {
         return this._isMapMode;
     }
+    get isDuplicate() {
+        return this._isDuplicate;
+    }
     get store() {
         return this._store;
     }
@@ -178,8 +246,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
      * value and returns the corresponding node or null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `ensureNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `ensureNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
      * is used to determine whether the input is a key, node, entry, or raw data. The
      * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
      * is used to specify the type of iteration to be performed. It has a default value of
@@ -211,7 +279,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function isNode checks if the input is an instance of BinaryTreeNode.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
      * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
      * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
      * accordingly.
@@ -228,7 +296,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | R} keyNodeEntryOrRaw - BTNRep<K, V, BinaryTreeNode<K, V>>
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | R} keyNodeEntryOrRaw - K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
      * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
      * checking if it is an object. If the parameter is an object, the function will return `true`,
      * indicating that it is of type `R`.
@@ -241,8 +309,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `isRealNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isRealNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
      * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
      * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
      * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
@@ -259,7 +327,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function checks if a given input is a valid node or null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
      * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
      * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
      * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
@@ -274,7 +342,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - BTNRep<K, V,
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - BTNRep<K, V,
      * BinaryTreeNode<K, V>>
      * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
      * property of the current object and returning a boolean value based on that comparison.
@@ -287,9 +355,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function `isRange` checks if the input parameter is an instance of the `Range` class.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>> | Range<K>}
-     * keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
-     * of type `BTNRep<K, V, BinaryTreeNode<K, V>>`, `NodePredicate<BinaryTreeNode<K, V>>`, or
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
+     * - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
+     * of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `NodePredicate<BinaryTreeNode<K, V>>`, or
      * `Range<K>`. The function checks if the `keyNodeEntry
      * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
      * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
@@ -305,8 +373,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
-     * `keyNodeOrEntry` can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It represents a
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It represents a
      * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
      * provided
      * @returns The function `isLeaf` returns a boolean value indicating whether the input
@@ -326,8 +394,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
      * with a length of 2.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-     * parameter in the `isEntry` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or type `R`.
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+     * parameter in the `isEntry` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or type `R`.
      * The function checks if the provided `keyNodeOrEntry` is of type `BTN
      * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
      * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
@@ -358,7 +426,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
      * and finding the correct insertion position.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `add` method you provided
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `add` method you provided
      * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
      * parameter in the method can accept different types of values:
      * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
@@ -383,16 +451,18 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         const queue = new queue_1.Queue([this._root]);
         let potentialParent; // Record the parent node of the potential insertion location
-        while (queue.size > 0) {
+        while (queue.length > 0) {
             const cur = queue.shift();
             if (!cur)
                 continue;
-            // Check for duplicate keys when newNode is not null
-            if (newNode !== null && cur.key === newNode.key) {
-                this._replaceNode(cur, newNode);
-                if (this._isMapMode)
-                    this._setValue(cur.key, newValue);
-                return true; // If duplicate keys are found, no insertion is performed
+            if (!this._isDuplicate) {
+                // Check for duplicate keys when newNode is not null
+                if (newNode !== null && cur.key === newNode.key) {
+                    this._replaceNode(cur, newNode);
+                    if (this._isMapMode)
+                        this._setValue(cur.key, newValue);
+                    return true; // If duplicate keys are found, no insertion is performed
+                }
             }
             // Record the first possible insertion location found
             if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
@@ -432,7 +502,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * each insertion was successful.
      * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
      * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-     * `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+     * `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
      * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
      * accepts an iterable of values. These values correspond to the keys or nodes being added in the
      * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
@@ -480,7 +550,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * The `refill` function clears the existing data structure and then adds new key-value pairs based
      * on the provided input.
      * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
-     * method can accept an iterable containing a mix of `BTNRep<K, V, BinaryTreeNode<K, V>>` objects or `R`
+     * method can accept an iterable containing a mix of `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` objects or `R`
      * objects.
      * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
      * accepts an iterable of values of type `V` or `undefined`.
@@ -495,7 +565,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
      * the deleted node along with information for tree balancing.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry
      * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
      * node, entry or raw data. The method returns an array of
      * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
@@ -557,15 +627,15 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
      * structure based on a given predicate or key, with options to return multiple results or just one.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
      * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
      * determines whether the search should stop after finding the first matching node. If `onlyOne` is
      * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
      * @param {C} callback - The `callback` parameter in the `search` function is a callback function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<BinaryTreeNode<K, V>>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `search` function is
+     * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `search` function is
      * used to specify the node from which the search operation should begin. It represents the starting
      * point in the binary tree where the search will be performed. If no specific `startNode` is
      * provided, the search operation will start from the root
@@ -626,12 +696,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
      * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `getNodes` function you provided takes several parameters:
      * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
      * determines whether to return only the first node that matches the criteria specified by the
      * `keyNodeEntryOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getNodes` function is used to specify the starting point for traversing the binary tree. It
      * represents the root node of the binary tree or the node from which the traversal should begin. If
      * not provided, the default value is set to `this._root
@@ -650,10 +720,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
      * predicate.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
      * node, entry, raw data, or a predicate function.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getNode` function is used to specify the starting point for searching for a node in a binary
      * tree. If no specific starting point is provided, the default value is set to `this._root`, which
      * is typically the root node of the binary tree.
@@ -673,10 +743,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * This function overrides the `get` method to retrieve the value associated with a specified key,
      * node, entry, raw data, or predicate in a data structure.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
      * following types:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `get`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `get`
      * method is used to specify the starting point for searching for a key or node in the binary tree.
      * If no specific starting point is provided, the default starting point is the root of the binary
      * tree (`this._root`).
@@ -705,10 +775,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
      * exists in the data structure.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
      * - The `keyNodeEntryOrPredicate` parameter in the `override has` method can accept one of
      * the following types:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `override` method is used to specify the starting point for the search operation within the data
      * structure. It defaults to `this._root` if not provided explicitly.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
@@ -752,7 +822,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
      * its height.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point for checking if the binary tree is perfectly balanced. It represents the root node of the
      * binary tree or a specific node from which the balance check should begin.
      * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
@@ -770,7 +840,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
      * or iterative methods.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `isBST`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `isBST`
      * function represents the starting point for checking whether a binary search tree (BST) is valid.
      * It can be a node in the BST or a reference to the root of the BST. If no specific node is
      * provided, the function will default to
@@ -829,10 +899,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(log n)
      *
      * The `getDepth` function calculates the depth between two nodes in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} dist - The `dist` parameter in the `getDepth`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } dist - The `dist` parameter in the `getDepth`
      * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
      * It is the target node for which you want to calculate the depth from the `startNode` node.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getDepth` function represents the starting point from which you want to calculate the depth of a
      * given node or entry in a binary tree. If no specific starting point is provided, the default value
      * for `startNode` is set to the root of the binary
@@ -859,7 +929,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
      * or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
      * point from which the height of the binary tree will be calculated. It can be a node in the binary
      * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
      * binary tree data structure.
@@ -904,7 +974,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach in TypeScript.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getMinHeight` function represents the starting node from which the minimum height of the binary
      * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
      * tree. If not provided, the default value is the root
@@ -970,7 +1040,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the path to the root. It is expected to be a function that takes a node as an argument and returns
      * a value based on that node. The return type of the callback function is determined by the generic
      * type `C
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} beginNode - The `beginNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } beginNode - The `beginNode` parameter in the
      * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
      * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
      * whether the resulting path from the given `beginNode` to the root should be in reverse order or
@@ -1002,7 +1072,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
      * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
      * value of `_DEFAULT_NODE_CALLBACK` if not specified.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -1048,7 +1118,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
      * which means it is a callback function that can accept either an optional binary tree node or null
      * as
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `getRightMost` function represents the starting point for finding the rightmost node in a binary
      * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
      * starting point is provided, the function will default
@@ -1142,33 +1212,35 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The function `dfs` performs a depth-first search traversal on a binary tree structure based on the
-     * specified parameters.
-     * @param {C} callback - The `callback` parameter is a generic type `C` that extends the
-     * `NodeCallback` interface with a type parameter of `OptNodeOrNull<BinaryTreeNode<K, V>>`. It has a default value of
-     * `this._DEFAULT_NODE_CALLBACK as C`.
-     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` method specifies the
-     * order in which the Depth-First Search (DFS) algorithm should traverse the nodes in the tree. The
-     * possible values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `dfs`
-     * method is used to specify the starting point for the Depth-First Search traversal. It can be
-     * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
-     * or it can be a
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` method specifies
-     * the type of iteration to be performed during the depth-first search traversal. It is used to
-     * determine the order in which nodes are visited during the traversal.
-     * @param [includeNull=false] - The `includeNull` parameter in the `dfs` method is a boolean flag
-     * that determines whether null values should be included in the traversal or not. If `includeNull`
-     * is set to `true`, then null values will be included in the traversal process. If it is set to
-     * `false`,
-     * @returns The `dfs` method is returning an array of the return type specified by the generic type
-     * parameter `C`. The return type is determined by the callback function provided to the method.
+     * The function performs a depth-first search on a binary tree structure based on the specified
+     * parameters.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the depth-first search. It should accept a `BinaryTreeNode` as an argument and
+     * return an optional node or null. The default value for this parameter is `_DEFAULT_NODE_CALLBACK`.
+     * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` function specifies
+     * the order in which the nodes are visited during a depth-first search traversal. The possible
+     * values for the `pattern` parameter are:
+     * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `dfs` function is a boolean flag
+     * that determines whether the depth-first search should stop after finding the first matching node
+     * or continue searching for all matching nodes. If `onlyOne` is set to `true`, the search will stop
+     * after finding the first matching node
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+     * startNode - The `startNode` parameter in the `dfs` function can be one of the following types:
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` function
+     * specifies the type of iteration to be performed during the Depth-First Search traversal. It is
+     * used to determine the order in which nodes are visited during the traversal. The possible values
+     * for `iterationType` are typically defined as an enum or a
+     * @param [includeNull=false] - The `includeNull` parameter in the `dfs` function determines whether
+     * null nodes should be included in the depth-first search traversal. If `includeNull` is set to
+     * `true`, null nodes will be included in the traversal process. If it is set to `false`, null nodes
+     * will be skipped
+     * @returns The `dfs` method is returning an array of the return type of the callback function `C`.
      */
-    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType, includeNull = false) {
+    dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false) {
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
-        return this._dfs(callback, pattern, startNode, iterationType, includeNull);
+        return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
     }
     /**
      * Time complexity: O(n)
@@ -1179,7 +1251,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
      * called on each node visited during the breadth-first search traversal. It is a generic type `C`
      * that extends the `NodeCallback` type, which takes a parameter of type `BinaryTreeNode<K, V>` or `null`.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `bfs`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `bfs`
      * function represents the starting point for the breadth-first search traversal in a binary tree. It
      * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
      * default value is the root node of the binary
@@ -1203,7 +1275,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                 startNode
             ]);
             const dfs = (level) => {
-                if (queue.size === 0)
+                if (queue.length === 0)
                     return;
                 const current = queue.shift();
                 ans.push(callback(current));
@@ -1225,8 +1297,8 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else {
             const queue = new queue_1.Queue([startNode]);
-            while (queue.size > 0) {
-                const levelSize = queue.size;
+            while (queue.length > 0) {
+                const levelSize = queue.length;
                 for (let i = 0; i < levelSize; i++) {
                     const current = queue.shift();
                     ans.push(callback(current));
@@ -1255,7 +1327,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * structure based on a specified callback and iteration type.
      * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
      * in the binary tree. It is optional and defaults to a default callback function if not provided.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `leaves`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `leaves`
      * method is used to specify the starting point for finding and processing the leaves of a binary
      * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
      * explicitly provided, the default value
@@ -1286,7 +1358,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else {
             const queue = new queue_1.Queue([startNode]);
-            while (queue.size > 0) {
+            while (queue.length > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
                     if (this.isLeaf(cur)) {
@@ -1310,7 +1382,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
      * the binary tree during the traversal. It is used to process each node and determine what
      * information to include in the output for each level of the tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `listLevels` function represents the starting point for traversing the binary tree. It can be
      * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
      * root of the binary tree.
@@ -1382,11 +1454,11 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Morris Traversal algorithm with different order patterns.
      * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
      * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-     * `NodeCallback<BinaryTreeNode<K, V>>` type. The default value for `callback` is `this._DEFAULT
+     * `NodeCallback<BinaryTreeNode<K, V> | null>` type. The default value for `callback` is `this._DEFAULT
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
      * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
      * values for the `pattern` parameter are:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `morris`
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `morris`
      * function is the starting point for the Morris traversal algorithm. It represents the root node of
      * the binary tree or the node from which the traversal should begin. It can be provided as either a
      * key, a node, an entry, or a reference
@@ -1495,20 +1567,6 @@ class BinaryTree extends base_1.IterableEntryBase {
         this._clone(cloned);
         return cloned;
     }
-    _clone(cloned) {
-        this.bfs(node => {
-            if (node === null)
-                cloned.add(null);
-            else {
-                if (this._isMapMode)
-                    cloned.add([node.key, this._store.get(node.key)]);
-                else
-                    cloned.add([node.key, node.value]);
-            }
-        }, this._root, this.iterationType, true);
-        if (this._isMapMode)
-            cloned._store = this._store;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1568,7 +1626,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
      * customizable options for displaying undefined, null, and sentinel nodes.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
      * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
      * the default is set to the root
@@ -1613,7 +1671,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * printing options for the binary tree. It is an optional parameter that allows you to customize how
      * the binary tree is printed, such as choosing between different traversal orders or formatting
      * options.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
      * `override print` method is used to specify the starting point for printing the binary tree. It can
      * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
      * provided, the default value is set to
@@ -1621,21 +1679,35 @@ class BinaryTree extends base_1.IterableEntryBase {
     print(options, startNode = this._root) {
         console.log(this.toVisual(startNode, options));
     }
+    _clone(cloned) {
+        this.bfs(node => {
+            if (node === null)
+                cloned.add(null);
+            else {
+                if (this._isMapMode)
+                    cloned.add([node.key, this._store.get(node.key)]);
+                else
+                    cloned.add([node.key, node.value]);
+            }
+        }, this._root, this.iterationType, true);
+        if (this._isMapMode)
+            cloned._store = this._store;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
      * or returns null.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The
      * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeOrEntry`, which
-     * can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. This parameter represents either a key, a
+     * can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. This parameter represents either a key, a
      * node, an entry
      * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
      * an optional parameter of type `V`. It represents the value associated with the key in the node
      * being created. If a `value` is provided, it will be used when creating the node. If
      * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-     * (`OptNodeOrNull<BinaryTreeNode<K, V>>`) based on the input parameters provided. The function checks the type of the
+     * (`BinaryTreeNode<K, V> | null | undefined`) based on the input parameters provided. The function checks the type of the
      * input parameter (`keyNodeOrEntry`) and processes it accordingly to return a node or null
      * value.
      */
@@ -1661,45 +1733,48 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
-     * The `_dfs` function performs a depth-first search traversal on a binary tree structure based on
-     * the specified order pattern and callback function.
+     * The `_dfs` function performs a depth-first search traversal on a binary tree, with customizable
+     * options for traversal order and node processing.
      * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
-     * called on each node visited during the depth-first search traversal. It is of type `C`, which
-     * extends `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`. The default value for this parameter is `this._DEFAULT
+     * called on each node visited during the depth-first search traversal. It is a generic type `C` that
+     * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback`
      * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
-     * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
-     * the following values:
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `_dfs`
-     * method is used to specify the starting point for the depth-first search traversal in a binary
-     * tree. It can be provided as either a `BTNRep` object or a reference to the root node
-     * of the tree. If no specific
+     * order in which the nodes are visited during a depth-first search traversal. It can have one of the
+     * following values:
+     * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `_dfs` method is a boolean flag
+     * that determines whether the traversal should stop after processing a single node. If `onlyOne` is
+     * set to `true`, the traversal will return as soon as a single node is processed. If it is set to
+     * `false
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+     * startNode - The `startNode` parameter in the `_dfs` method is used to specify the starting node
+     * for the depth-first search traversal. It can be provided in different forms:
      * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
-     * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
-     * binary tree. It can have two possible values:
-     * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method is a boolean flag
-     * that determines whether null nodes should be included in the depth-first search traversal. If
-     * `includeNull` is set to `true`, null nodes will be considered during the traversal process. If it
-     * is set to `false`,
-     * @param shouldVisitLeft - The `shouldVisitLeft` parameter is a function that takes a node as input
-     * and returns a boolean value. It is used to determine whether the left child of a node should be
-     * visited during the depth-first search traversal. By default, it checks if the node is truthy (not
-     * null or undefined
-     * @param shouldVisitRight - The `shouldVisitRight` parameter is a function that takes a node as an
-     * argument and returns a boolean value. It is used to determine whether the right child of a node
-     * should be visited during the depth-first search traversal. The default implementation checks if
-     * the node is truthy before visiting the right child
-     * @param shouldVisitRoot - The `shouldVisitRoot` parameter is a function that takes a node as an
-     * argument and returns a boolean value. It is used to determine whether the root node should be
-     * visited during the depth-first search traversal based on certain conditions. The default
-     * implementation checks if the node is a real node or null based
-     * @param shouldProcessRoot - The `shouldProcessRoot` parameter is a function that takes a node as an
-     * argument and returns a boolean value indicating whether the node should be processed during the
-     * depth-first search traversal. The default implementation checks if the node is a real node or null
-     * based on the `includeNull` flag. If `
-     * @returns The function `_dfs` returns an array of the return type of the callback function provided
-     * as input.
+     * specifies whether the traversal should be done recursively or iteratively. It can have two
+     * possible values:
+     * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method determines whether
+     * null nodes should be included in the traversal process. If `includeNull` is set to `true`, the
+     * method will consider null nodes as valid nodes to visit or process. If `includeNull` is set to
+     * `false`,
+     * @param shouldVisitLeft - The `shouldVisitLeft` parameter in the `_dfs` method is a function that
+     * determines whether the left child of a node should be visited during the Depth-First Search
+     * traversal. By default, it checks if the node is not null or undefined before visiting the left
+     * child. You can customize this behavior
+     * @param shouldVisitRight - The `shouldVisitRight` parameter in the `_dfs` method is a function that
+     * determines whether to visit the right child node of the current node during a depth-first search
+     * traversal. The default implementation of this function checks if the node is not null or undefined
+     * before deciding to visit it.
+     * @param shouldVisitRoot - The `shouldVisitRoot` parameter in the `_dfs` method is a function that
+     * determines whether a given node should be visited during the depth-first search traversal. The
+     * function takes a node as an argument and returns a boolean value indicating whether the node
+     * should be visited.
+     * @param shouldProcessRoot - The `shouldProcessRoot` parameter in the `_dfs` method is a function
+     * that determines whether the root node should be processed during the Depth-First Search traversal.
+     * It takes a node (BinaryTreeNode<K, V> | null | undefined) as input and returns a boolean value. If
+     * the function
+     * @returns The `_dfs` method returns an array of the return type of the provided callback function
+     * `C`.
      */
-    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = node => !!node, shouldVisitRight = node => !!node, shouldVisitRoot = node => {
+    _dfs(callback = this._DEFAULT_NODE_CALLBACK, pattern = 'IN', onlyOne = false, startNode = this._root, iterationType = this.iterationType, includeNull = false, shouldVisitLeft = node => !!node, shouldVisitRight = node => !!node, shouldVisitRoot = node => {
         if (includeNull)
             return this.isRealNodeOrNull(node);
         return this.isRealNode(node);
@@ -1713,31 +1788,40 @@ class BinaryTree extends base_1.IterableEntryBase {
                 if (!shouldVisitRoot(node))
                     return;
                 const visitLeft = () => {
-                    if (shouldVisitLeft(node))
+                    if (shouldVisitLeft(node) && (node === null || node === void 0 ? void 0 : node.left) !== undefined)
                         dfs(node === null || node === void 0 ? void 0 : node.left);
                 };
                 const visitRight = () => {
-                    if (shouldVisitRight(node))
+                    if (shouldVisitRight(node) && (node === null || node === void 0 ? void 0 : node.right) !== undefined)
                         dfs(node === null || node === void 0 ? void 0 : node.right);
                 };
                 switch (pattern) {
                     case 'IN':
                         visitLeft();
-                        if (shouldProcessRoot(node))
+                        if (shouldProcessRoot(node)) {
                             ans.push(callback(node));
+                            if (onlyOne)
+                                return;
+                        }
                         visitRight();
                         break;
                     case 'PRE':
-                        if (shouldProcessRoot(node))
+                        if (shouldProcessRoot(node)) {
                             ans.push(callback(node));
+                            if (onlyOne)
+                                return;
+                        }
                         visitLeft();
                         visitRight();
                         break;
                     case 'POST':
                         visitLeft();
                         visitRight();
-                        if (shouldProcessRoot(node))
+                        if (shouldProcessRoot(node)) {
                             ans.push(callback(node));
+                            if (onlyOne)
+                                return;
+                        }
                         break;
                 }
             };
@@ -1766,8 +1850,11 @@ class BinaryTree extends base_1.IterableEntryBase {
                 if (!shouldVisitRoot(cur.node))
                     continue;
                 if (cur.opt === common_1.DFSOperation.PROCESS) {
-                    if (shouldProcessRoot(cur.node))
+                    if (shouldProcessRoot(cur.node) && cur.node !== undefined) {
                         ans.push(callback(cur.node));
+                        if (onlyOne)
+                            return ans;
+                    }
                 }
                 else {
                     switch (pattern) {
@@ -1913,12 +2000,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} srcNode - The `srcNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } srcNode - The `srcNode` parameter in the
      * `_swapProperties` method can be either a BTNRep object containing key and value
      * properties, or it can be of type R.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} destNode - The `destNode` parameter in the
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } destNode - The `destNode` parameter in the
      * `_swapProperties` method represents the node or entry where the properties will be swapped with
-     * the `srcNode`. It can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. The method ensures that
+     * the `srcNode`. It can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. The method ensures that
      * both `srcNode
      * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
      * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
@@ -1978,7 +2065,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function _setRoot sets the root node of a data structure while updating the parent reference
      * of the previous root node.
-     * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<BinaryTreeNode<K, V>>`, which means
+     * @param v - The parameter `v` in the `_setRoot` method is of type `BinaryTreeNode<K, V> | null | undefined`, which means
      * it can either be an optional `BinaryTreeNode<K, V>` type or `null`.
      */
     _setRoot(v) {
@@ -1993,7 +2080,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
      * predicate function for a binary tree node.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
      * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
      * parameter `keyNodeEntryOrPredicate` is transformed into a valid predicate function that can be
      * used for filtering nodes in a binary tree.
@@ -2008,9 +2095,17 @@ class BinaryTree extends base_1.IterableEntryBase {
             return (node) => node === keyNodeEntryOrPredicate;
         if (this.isEntry(keyNodeEntryOrPredicate)) {
             const [key] = keyNodeEntryOrPredicate;
-            return (node) => node.key === key;
+            return (node) => {
+                if (!node)
+                    return false;
+                return node.key === key;
+            };
         }
-        return (node) => node.key === keyNodeEntryOrPredicate;
+        return (node) => {
+            if (!node)
+                return false;
+            return node.key === keyNodeEntryOrPredicate;
+        };
     }
     /**
      * Time Complexity: O(1)
@@ -2033,8 +2128,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `_extractKey` method you provided is a
-     * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `BTNRep<K, V, BinaryTreeNode<K, V>>`,
+     * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `_extractKey` method you provided is a
+     * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `BinaryTreeNode<K, V>`, and `
      * @returns The `_extractKey` method returns the key value extracted from the `keyNodeOrEntry`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on