min-heap-typed 1.42.3 → 1.42.5

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

@@ -88,7 +88,7 @@ class BinaryTree {
      */
     constructor(options) {
         this.iterationType = types_1.IterationType.ITERATIVE;
-        this._root = null;
+        this._root = undefined;
         this._size = 0;
         this.defaultOneParamCallback = (node) => node.key;
         if (options !== undefined) {
@@ -121,7 +121,7 @@ class BinaryTree {
      * Clear the binary tree, removing all nodes.
      */
     clear() {
-        this._setRoot(null);
+        this._setRoot(undefined);
         this._size = 0;
     }
     /**
@@ -293,10 +293,10 @@ class BinaryTree {
     /**
      * The function `getDepth` calculates the depth of a given node in a binary tree relative to a
      * specified root node.
-     * @param {BTNKey | N | null} distNode - The `distNode` parameter represents the node
+     * @param {BTNKey | N | null | undefined} distNode - The `distNode` parameter represents the node
      * whose depth we want to find in the binary tree. It can be either a node object (`N`), a key value
      * of the node (`BTNKey`), or `null`.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter represents the
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node from which we want to calculate the depth. It can be either a node object or the key
      * of a node in the binary tree. If no value is provided for `beginRoot`, it defaults to the root
      * node of the binary tree.
@@ -320,7 +320,7 @@ class BinaryTree {
     /**
      * The `getHeight` function calculates the maximum height of a binary tree using either recursive or
      * iterative approach.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter represents the
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node from which the height of the binary tree is calculated. It can be either a node
      * object (`N`), a key value of a node in the tree (`BTNKey`), or `null` if no starting
      * node is specified. If `
@@ -366,7 +366,7 @@ class BinaryTree {
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a
      * recursive or iterative approach.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node from which we want to
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node from which we want to
      * calculate the minimum height of the tree. It is optional and defaults to the root of the tree if
      * not provided.
      * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
@@ -420,7 +420,7 @@ class BinaryTree {
     /**
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
      * height of the tree.
-     * @param {N | null} beginRoot - The parameter `beginRoot` is of type `N | null`, which means it can
+     * @param {N | null | undefined} beginRoot - The parameter `beginRoot` is of type `N | null | undefined`, which means it can
      * either be of type `N` (representing a node in a tree) or `null` (representing an empty tree).
      * @returns The method is returning a boolean value.
      */
@@ -441,7 +441,7 @@ class BinaryTree {
      * first node that matches the identifier. If set to true, the function will return an array with
      * only one element (or an empty array if no matching node is found). If set to false (default), the
      * function will continue searching for all
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node from which the
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node from which the
      * traversal of the binary tree will begin. It is optional and defaults to the root of the binary
      * tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
@@ -574,7 +574,7 @@ class BinaryTree {
     /**
      * The function `getLeftMost` returns the leftmost node in a binary tree, either using recursive or
      * iterative traversal.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for finding the leftmost node in a binary tree. It can be either a node object (`N`), a key value
      * of a node (`BTNKey`), or `null` if the tree is empty.
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
@@ -608,8 +608,8 @@ class BinaryTree {
     /**
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node from which we want to
-     * find the rightmost node. It is of type `N | null`, which means it can either be a node of type `N`
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node from which we want to
+     * find the rightmost node. It is of type `N | null | undefined`, which means it can either be a node of type `N`
      * or `null`. If it is `null`, it means there is no starting node
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the rightmost node in a binary tree. It can have two possible values:
@@ -698,7 +698,7 @@ class BinaryTree {
      * subtree traversal. It takes a single argument, which is the current node being traversed, and
      * returns a value. The return values from each callback invocation will be collected and returned as
      * an array.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {BTNKey | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for traversing the subtree. It can be either a node object, a key value of a node, or `null` to
      * start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -717,12 +717,12 @@ class BinaryTree {
                 if (cur !== undefined) {
                     ans.push(callback(cur));
                     if (includeNull) {
-                        cur !== null && cur.left !== undefined && _traverse(cur.left);
-                        cur !== null && cur.right !== undefined && _traverse(cur.right);
+                        cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
+                        cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
                     }
                     else {
-                        cur !== null && cur.left && _traverse(cur.left);
-                        cur !== null && cur.right && _traverse(cur.right);
+                        cur && cur.left && _traverse(cur.left);
+                        cur && cur.right && _traverse(cur.right);
                     }
                 }
             };
@@ -735,18 +735,27 @@ class BinaryTree {
                 if (cur !== undefined) {
                     ans.push(callback(cur));
                     if (includeNull) {
-                        cur !== null && cur.right !== undefined && stack.push(cur.right);
-                        cur !== null && cur.left !== undefined && stack.push(cur.left);
+                        cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
+                        cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
                     }
                     else {
-                        cur !== null && cur.right && stack.push(cur.right);
-                        cur !== null && cur.left && stack.push(cur.left);
+                        cur && cur.right && stack.push(cur.right);
+                        cur && cur.left && stack.push(cur.left);
                     }
                 }
             }
         }
         return ans;
     }
+    isNode(node) {
+        return node instanceof BinaryTreeNode && node.key.toString() !== 'NaN';
+    }
+    isNIL(node) {
+        return node instanceof BinaryTreeNode && node.key.toString() === 'NaN';
+    }
+    isNodeOrNull(node) {
+        return this.isNode(node) || node === null;
+    }
     /**
      * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
      * function on each node according to a specified order pattern.
@@ -755,7 +764,7 @@ class BinaryTree {
      * is `this.defaultOneParamCallback`, which is a callback function defined elsewhere in the code.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. There are three possible values for `pattern`:
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
      * search. It determines where the search will begin in the tree or graph structure. If `beginRoot`
      * is `null`, an empty array will be returned.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -772,50 +781,50 @@ class BinaryTree {
                 switch (pattern) {
                     case 'in':
                         if (includeNull) {
-                            if (node !== null && node.left !== undefined)
+                            if (node && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
-                            ans.push(callback(node));
-                            if (node !== null && node.right !== undefined)
+                            this.isNodeOrNull(node) && ans.push(callback(node));
+                            if (node && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
                         }
                         else {
-                            if (node !== null && node.left)
+                            if (node && node.left)
                                 _traverse(node.left);
-                            ans.push(callback(node));
-                            if (node !== null && node.right)
+                            this.isNode(node) && ans.push(callback(node));
+                            if (node && node.right)
                                 _traverse(node.right);
                         }
                         break;
                     case 'pre':
                         if (includeNull) {
-                            ans.push(callback(node));
-                            if (node !== null && node.left !== undefined)
+                            this.isNodeOrNull(node) && ans.push(callback(node));
+                            if (node && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
-                            if (node !== null && node.right !== undefined)
+                            if (node && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
                         }
                         else {
-                            ans.push(callback(node));
-                            if (node !== null && node.left)
+                            this.isNode(node) && ans.push(callback(node));
+                            if (node && node.left)
                                 _traverse(node.left);
-                            if (node !== null && node.right)
+                            if (node && node.right)
                                 _traverse(node.right);
                         }
                         break;
                     case 'post':
                         if (includeNull) {
-                            if (node !== null && node.left !== undefined)
+                            if (node && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
-                            if (node !== null && node.right !== undefined)
+                            if (node && this.isNodeOrNull(node.right))
                                 _traverse(node.right);
-                            ans.push(callback(node));
+                            this.isNodeOrNull(node) && ans.push(callback(node));
                         }
                         else {
-                            if (node !== null && node.left)
+                            if (node && node.left)
                                 _traverse(node.left);
-                            if (node !== null && node.right)
+                            if (node && node.right)
                                 _traverse(node.right);
-                            ans.push(callback(node));
+                            this.isNode(node) && ans.push(callback(node));
                         }
                         break;
                 }
@@ -827,7 +836,7 @@ class BinaryTree {
             const stack = [{ opt: 0, node: beginRoot }];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                if (cur === undefined)
+                if (cur === undefined || this.isNIL(cur.node))
                     continue;
                 if (includeNull) {
                     if (cur.node === undefined)
@@ -874,7 +883,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that will be called for each node in the
      * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
      * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
      * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
      * will not be performed and an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
@@ -894,9 +903,9 @@ class BinaryTree {
                 const current = queue.shift();
                 ans.push(callback(current));
                 if (includeNull) {
-                    if (current && current.left !== undefined)
+                    if (current && this.isNodeOrNull(current.left))
                         queue.push(current.left);
-                    if (current && current.right !== undefined)
+                    if (current && this.isNodeOrNull(current.right))
                         queue.push(current.right);
                 }
                 else {
@@ -917,9 +926,9 @@ class BinaryTree {
                     const current = queue.shift();
                     ans.push(callback(current));
                     if (includeNull) {
-                        if (current !== null && current.left !== undefined)
+                        if (current && this.isNodeOrNull(current.left))
                             queue.push(current.left);
-                        if (current !== null && current.right !== undefined)
+                        if (current && this.isNodeOrNull(current.right))
                             queue.push(current.right);
                     }
                     else {
@@ -939,7 +948,7 @@ class BinaryTree {
      * @param {C} callback - The `callback` parameter is a function that will be called on each node in
      * the tree. It takes a node as input and returns a value. The return type of the callback function
      * is determined by the generic type `C`.
-     * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
      * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
      * from the root node of the binary tree.
      * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
@@ -959,9 +968,9 @@ class BinaryTree {
                     levelsNodes[level] = [];
                 levelsNodes[level].push(callback(node));
                 if (includeNull) {
-                    if (node && node.left !== undefined)
+                    if (node && this.isNodeOrNull(node.left))
                         _recursive(node.left, level + 1);
-                    if (node && node.right !== undefined)
+                    if (node && this.isNodeOrNull(node.right))
                         _recursive(node.right, level + 1);
                 }
                 else {
@@ -982,9 +991,9 @@ class BinaryTree {
                     levelsNodes[level] = [];
                 levelsNodes[level].push(callback(node));
                 if (includeNull) {
-                    if (node && node.right !== undefined)
+                    if (node && this.isNodeOrNull(node.right))
                         stack.push([node.right, level + 1]);
-                    if (node && node.left !== undefined)
+                    if (node && this.isNodeOrNull(node.left))
                         stack.push([node.left, level + 1]);
                 }
                 else {
@@ -1043,7 +1052,7 @@ class BinaryTree {
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the Morris
+     * @param {N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node for the Morris
      * traversal. It specifies the root node of the tree from which the traversal should begin. If
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
@@ -1192,7 +1201,7 @@ class BinaryTree {
     }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to
+     * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
      * the binary tree. It can be either a node object or `null`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
      * be added as a child.
@@ -1230,7 +1239,7 @@ class BinaryTree {
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.
-     * @param {N | null} v - The parameter `v` is of type `N | null`, which means it can either be of
+     * @param {N | null | undefined} v - The parameter `v` is of type `N | null | undefined`, which means it can either be of
      * type `N` or `null`.
      */
     _setRoot(v) {
@@ -1239,5 +1248,58 @@ class BinaryTree {
         }
         this._root = v;
     }
+    print(beginRoot = this.root) {
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (node === undefined || node === null) {
+                return [[], 0, 0, 0];
+            }
+            if (node && node.right === undefined && node.left === undefined) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (node && node.right === undefined) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (node && node.left === undefined) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
 }
 exports.BinaryTree = BinaryTree;

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

@@ -10,7 +10,28 @@ import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
+    parent: N | undefined;
     constructor(key: BTNKey, value?: V);
+    protected _left: N | undefined;
+    /**
+     * Get the left child node.
+     */
+    get left(): N | undefined;
+    /**
+     * Set the left child node.
+     * @param {N | undefined} v - The left child node.
+     */
+    set left(v: N | undefined);
+    protected _right: N | undefined;
+    /**
+     * Get the right child node.
+     */
+    get right(): N | undefined;
+    /**
+     * Set the right child node.
+     * @param {N | undefined} v - The right child node.
+     */
+    set right(v: N | undefined);
 }
 export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
     /**
@@ -20,6 +41,11 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * binary search tree.
      */
     constructor(options?: BSTOptions);
+    protected _root: N | undefined;
+    /**
+     * Get the root node of the binary tree.
+     */
+    get root(): N | undefined;
     /**
      * The function creates a new binary search tree node with the given key and value.
      * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -32,33 +58,33 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * The `add` function in a binary search tree class inserts a new node with a given key and value
      * into the tree.
-     * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-     * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+     * @param {BTNKey | N | undefined} keyOrNode - The `keyOrNode` parameter can be either a
+     * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `undefined`.
      * @param [value] - The `value` parameter is the value to be assigned to the new node being added to the
      * binary search tree.
      * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
-     * was not added or if the parameters were invalid, it returns null or undefined.
+     * was not added or if the parameters were invalid, it returns undefined or undefined.
      */
-    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
     /**
      * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
      * maintaining balance.
      * @param {[BTNKey | N, V][]} keysOrNodes - The `arr` parameter in the `addMany` function
      * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
      * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
-     * `null
+     * `undefined
      * @param {V[]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be used.
      * It can have two possible values:
-     * @returns The `addMany` function returns an array of `N`, `null`, or `undefined` values.
+     * @returns The `addMany` function returns an array of `N`, `undefined`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | null | undefined)[];
+    addMany(keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[], data?: V[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * The function `lastKey` returns the key of the rightmost node 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.
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting point for finding the last
+     * @param {N | undefined} beginRoot - The `beginRoot` parameter is the starting point for finding the last
      * key in a binary tree. It represents the root node of the subtree from which the search for the
      * last key should begin. If no specific `beginRoot` is provided, the search will start from the root
      * of the entire binary
@@ -69,7 +95,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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?: N | null, iterationType?: IterationType): BTNKey;
+    lastKey(beginRoot?: N | undefined, iterationType?: IterationType): BTNKey;
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
@@ -84,14 +110,14 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * the first node that matches the nodeProperty. If set to true, the function will return an array
      * containing only that node. If set to false (default), the function will continue the traversal and
      * return an array containing all nodes that match the node
-     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
+     * @param {N | undefined} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
      * specifies the root node of the binary tree from which the traversal should begin. If `beginRoot`
-     * is `null`, an empty array will be returned.
+     * is `undefined`, an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: N | undefined, iterationType?: IterationType): N[];
     /**
      * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
      * nodes that have a key value lesser or greater than a target key value.
@@ -101,15 +127,15 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @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 can take one
      * of the following values:
-     * @param {BTNKey | N | null} targetNode - The `targetNode` parameter in the
+     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter in the
      * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
      * start. It can be either a reference to a specific node (`N`), the key of a node
-     * (`BTNKey`), or `null` to
+     * (`BTNKey`), or `undefined` to
      * @param iterationType - The `iterationType` parameter determines whether the traversal should be
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | null, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
      * 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.
@@ -136,6 +162,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
     protected _comparator: BSTComparator;
+    protected _setRoot(v: N | undefined): void;
     /**
      * 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.