min-heap-typed 1.51.0 → 1.51.2

package/dist/data-structures/binary-tree/avl-tree-multi-map.js

@@ -194,7 +194,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * decremented by 1 and
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
         var _a;
         const deletedResult = [];
         if (!this.root)

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

@@ -108,7 +108,7 @@ export declare class AVLTree<K = any, V = any, NODE extends AVLTreeNode<K, V, NO
      * `callback` function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
      * parameter of type `NODE
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */

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

@@ -133,11 +133,11 @@ class AVLTree extends bst_1.BST {
      * `callback` function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
      * parameter of type `NODE
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         if (identifier instanceof AVLTreeNode)
             callback = (node => node);
         const deletedResults = super.delete(identifier, callback);

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

@@ -97,6 +97,12 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @returns The size of the object, which is a number.
      */
     get size(): number;
+    protected _NIL: NODE;
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL(): NODE;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -140,19 +146,18 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
      * @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 class NODE.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -167,11 +172,12 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      */
     isNIL(node: KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
+    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
     /**
      * Time Complexity O(n)
      * Space Complexity O(1)
@@ -576,7 +582,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * 4. `middleIndex`: The index of the middle character
      */
     protected _displayAux(node: NODE | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
-    protected _defaultOneParamCallback: (node: NODE | null | undefined) => K | undefined;
+    protected _DEFAULT_CALLBACK: (node: NODE | null | undefined) => K | undefined;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {NODE} srcNode - The source node to swap.

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

@@ -107,7 +107,8 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = 'ITERATIVE';
         this._extractor = (key) => (typeof key === 'number' ? key : Number(key));
-        this._defaultOneParamCallback = (node) => (node ? node.key : undefined);
+        this._NIL = new BinaryTreeNode(NaN);
+        this._DEFAULT_CALLBACK = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
             if (iterationType)
@@ -141,6 +142,13 @@ class BinaryTree extends base_1.IterableEntryBase {
     get size() {
         return this._size;
     }
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL() {
+        return this._NIL;
+    }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -217,23 +225,31 @@ class BinaryTree extends base_1.IterableEntryBase {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
-            res = keyOrNodeOrEntry;
+            return keyOrNodeOrEntry;
         }
         else if (this.isEntry(keyOrNodeOrEntry)) {
             if (keyOrNodeOrEntry[0] === null)
-                res = null;
-            else if (keyOrNodeOrEntry[0] !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+                return null;
+            if (keyOrNodeOrEntry[0] === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
         }
         else {
             if (keyOrNodeOrEntry === null)
-                res = null;
-            else if (keyOrNodeOrEntry !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+                return null;
+            if (keyOrNodeOrEntry === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
-        return res;
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+        return this.isRealNode(node) || node === null;
     }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
@@ -243,15 +259,6 @@ class BinaryTree extends base_1.IterableEntryBase {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry) {
-        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-    }
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -259,7 +266,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+        if (!this.isNode(node))
+            return false;
+        return node !== this.NIL;
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -267,15 +276,16 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isNIL(node) {
-        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+        return node === this.NIL;
     }
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node) {
-        return this.isRealNode(node) || node === null;
+    isEntry(keyOrNodeOrEntry) {
+        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
     }
     /**
      * Time Complexity O(n)
@@ -409,14 +419,14 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specific node based on its value or object.
      * @param {C} callback - The `callback` parameter is a function that is used to determine the
      * identifier of the node to be deleted. It is optional and has a default value of
-     * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+     * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         const deletedResult = [];
         if (!this.root)
             return deletedResult;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         const curr = this.getNode(identifier, callback);
         if (!curr)
@@ -475,7 +485,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specific value.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+     * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
      * default
      * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
@@ -488,39 +498,39 @@ class BinaryTree extends base_1.IterableEntryBase {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `NODE`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                this.isRealNode(cur.left) && dfs(cur.left);
+                this.isRealNode(cur.right) && dfs(cur.right);
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
-                if (cur) {
+            const stack = [beginRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                if (this.isRealNode(cur)) {
                     if (callback(cur) === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    this.isRealNode(cur.left) && stack.push(cur.left);
+                    this.isRealNode(cur.right) && stack.push(cur.right);
                 }
             }
         }
@@ -551,10 +561,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * nodes are visited during the search.
      * @returns a value of type `NODE | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
@@ -579,27 +587,27 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!this.root)
             return undefined;
         if (iterationType === 'RECURSIVE') {
-            const _dfs = (cur) => {
+            const dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!cur.left && !cur.right)
                     return;
                 if (cur.left)
-                    return _dfs(cur.left);
+                    return dfs(cur.left);
                 if (cur.right)
-                    return _dfs(cur.right);
+                    return dfs(cur.right);
             };
-            return _dfs(this.root);
+            return dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [this.root];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (cur) {
                     if (cur.key === key)
                         return cur;
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    cur.left && stack.push(cur.left);
+                    cur.right && stack.push(cur.right);
                 }
             }
         }
@@ -630,10 +638,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
         return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
     /**
@@ -661,8 +667,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
@@ -967,21 +973,21 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!this.isRealNode(beginRoot))
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse(cur.left);
+                return dfs(cur.left);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const dfs = (0, utils_1.trampoline)((cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse.cont(cur.left);
+                return dfs.cont(cur.left);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1011,21 +1017,21 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!beginRoot)
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse(cur.right);
+                return dfs(cur.right);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const dfs = (0, utils_1.trampoline)((cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse.cont(cur.right);
+                return dfs.cont(cur.right);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1110,65 +1116,65 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `false`, null or undefined
      * @returns an array of values that are the return values of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (node) => {
+            const dfs = (node) => {
                 switch (pattern) {
                     case 'IN':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'PRE':
                         if (includeNull) {
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isRealNode(node) && ans.push(callback(node));
                         }
                         break;
                 }
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
             // 0: visit, 1: print
@@ -1241,14 +1247,14 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const queue = new queue_1.Queue([beginRoot]);
-            const traverse = (level) => {
+            const dfs = (level) => {
                 if (queue.size === 0)
                     return;
                 const current = queue.shift();
@@ -1265,9 +1271,9 @@ class BinaryTree extends base_1.IterableEntryBase {
                     if (this.isRealNode(current.right))
                         queue.push(current.right);
                 }
-                traverse(level + 1);
+                dfs(level + 1);
             };
-            traverse(0);
+            dfs(0);
         }
         else {
             const queue = new queue_1.Queue([beginRoot]);
@@ -1318,7 +1324,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1390,7 +1396,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root) {
+    morris(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root) {
         beginRoot = this.ensureNode(beginRoot);
         if (beginRoot === null)
             return [];

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
+import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
@@ -209,6 +209,32 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns The method returns an array of nodes (`NODE[]`).
      */
     getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
+     * @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`.
+     */
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | undefined;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)