data-structure-typed 1.42.6 → 1.42.7

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

@@ -102,19 +102,20 @@ class BinaryTree {
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        if (options !== undefined) {
+        if (options) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this.iterationType = iterationType;
         }
+        this._size = 0;
     }
-    _root = undefined;
+    _root;
     /**
      * Get the root node of the binary tree.
      */
     get root() {
         return this._root;
     }
-    _size = 0;
+    _size;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -130,20 +131,6 @@ class BinaryTree {
     createNode(key, value) {
         return new BinaryTreeNode(key, value);
     }
-    /**
-     * Clear the binary tree, removing all nodes.
-     */
-    clear() {
-        this._setRoot(undefined);
-        this._size = 0;
-    }
-    /**
-     * Check if the binary tree is empty.
-     * @returns {boolean} - True if the binary tree is empty, false otherwise.
-     */
-    isEmpty() {
-        return this.size === 0;
-    }
     /**
      * Add a node with the given key and value to the binary tree.
      * @param {BTNKey | N | null} keyOrNode - The key or node to add to the binary tree.
@@ -177,7 +164,7 @@ class BinaryTree {
         if (keyOrNode === null) {
             needInsert = null;
         }
-        else if (typeof keyOrNode === 'number') {
+        else if (this.isNodeKey(keyOrNode)) {
             needInsert = this.createNode(keyOrNode, value);
         }
         else if (keyOrNode instanceof BinaryTreeNode) {
@@ -186,19 +173,12 @@ class BinaryTree {
         else {
             return;
         }
-        // const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-        // const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
         if (this.root) {
-            // if (existNode) {
-            //   existNode.value = value;
-            //   inserted = existNode;
-            // } else {
             inserted = _bfs(this.root, needInsert);
-            // }
         }
         else {
             this._setRoot(needInsert);
-            if (needInsert !== null) {
+            if (needInsert) {
                 this._size = 1;
             }
             else {
@@ -235,40 +215,41 @@ class BinaryTree {
      * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
      * @param {(BTNKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
      * `BTNKey` or `N` values.
-     * @param {N[] | Array<V>} [data] - The `data` parameter is an optional array of values that will be assigned to
+     * @param {N[] | Array<V>} [values] - The `data` parameter is an optional array of values that will be assigned to
      * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
      * array. Each value in the `data` array will be assigned to the
      * @returns The method is returning a boolean value.
      */
-    refill(keysOrNodes, data) {
+    refill(keysOrNodes, values) {
         this.clear();
-        return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
+        return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
     }
     /**
      * The `delete` function removes a node from a binary search tree and returns the deleted node along
      * with the parent node that needs to be balanced.
      * a key (`BTNKey`). If it is a key, the function will find the corresponding node in the
      * binary tree.
-     * @returns an array of `BinaryTreeDeletedResult<N>` objects.
+     * @returns an array of `BiTreeDeleteResult<N>` objects.
      * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
      * `BTNKey` or a generic type `N`. It represents the property of the node that we are
      * searching for. It can be a specific key value or any other property of the node.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this.defaultOneParamCallback`, which
+     * `this._defaultOneParamCallback`, which
      */
-    delete(identifier, callback = this.defaultOneParamCallback) {
-        const bstDeletedResult = [];
+    delete(identifier, callback = this._defaultOneParamCallback) {
+        const deletedResult = [];
         if (!this.root)
-            return bstDeletedResult;
+            return deletedResult;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         const curr = this.getNode(identifier, callback);
         if (!curr)
-            return bstDeletedResult;
+            return deletedResult;
         const parent = curr?.parent ? curr.parent : null;
-        let needBalanced = null, orgCurrent = curr;
+        let needBalanced = undefined;
+        let orgCurrent = curr;
         if (!curr.left) {
             if (!parent) {
                 // Handle the case when there's only one root node
@@ -300,8 +281,8 @@ class BinaryTree {
             }
         }
         this._size = this.size - 1;
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
-        return bstDeletedResult;
+        deletedResult.push({ deleted: orgCurrent, needBalanced });
+        return deletedResult;
     }
     /**
      * The function `getDepth` calculates the depth of a given node in a binary tree relative to a
@@ -316,10 +297,8 @@ class BinaryTree {
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
     getDepth(distNode, beginRoot = this.root) {
-        if (typeof distNode === 'number')
-            distNode = this.getNode(distNode);
-        if (typeof beginRoot === 'number')
-            beginRoot = this.getNode(beginRoot);
+        distNode = this.ensureNotKey(distNode);
+        beginRoot = this.ensureNotKey(beginRoot);
         let depth = 0;
         while (distNode?.parent) {
             if (distNode === beginRoot) {
@@ -343,8 +322,7 @@ class BinaryTree {
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.getNode(beginRoot);
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -365,12 +343,10 @@ class BinaryTree {
             let maxHeight = 0;
             while (stack.length > 0) {
                 const { node, depth } = stack.pop();
-                if (node.left) {
+                if (node.left)
                     stack.push({ node: node.left, depth: depth + 1 });
-                }
-                if (node.right) {
+                if (node.right)
                     stack.push({ node: node.right, depth: depth + 1 });
-                }
                 maxHeight = Math.max(maxHeight, depth);
             }
             return maxHeight;
@@ -387,6 +363,7 @@ class BinaryTree {
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -448,7 +425,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this.defaultOneParamCallback`, which
+     * `this._defaultOneParamCallback`, which
      * @param [onlyOne=false] - A boolean value indicating whether to stop searching after finding the
      * 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
@@ -460,11 +437,14 @@ class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns The function `getNodes` returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
+        beginRoot = this.ensureNotKey(beginRoot);
+        if (!beginRoot)
+            return [];
         const ans = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
@@ -505,7 +485,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * `this.defaultOneParamCallback` is used if no callback function is
+     * `this._defaultOneParamCallback` is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the node from which the search should begin. By default, it is set to `this.root`, which means the
      * search will start from the root node of the binary tree. However, you can provide a different node
@@ -514,7 +494,7 @@ class BinaryTree {
      * performed when searching for nodes in the binary tree. It can have one of the following values:
      * @returns a boolean value.
      */
-    has(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -527,18 +507,72 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`this.defaultOneParamCallback`) is used if no callback function is
+     * (`this._defaultOneParamCallback`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    getNode(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
     }
+    /**
+     * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
+     * recursive or iterative iteration.
+     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to find the node with the matching key value.
+     * @param iterationType - The `iterationType` parameter is used to determine whether the search for
+     * the node with the given key should be performed iteratively or recursively. It has two possible
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+        if (!this.root)
+            return undefined;
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const _dfs = (cur) => {
+                if (cur.key === key)
+                    return cur;
+                if (!cur.left && !cur.right)
+                    return;
+                if (cur.left)
+                    return _dfs(cur.left);
+                if (cur.right)
+                    return _dfs(cur.right);
+            };
+            return _dfs(this.root);
+        }
+        else {
+            const queue = new queue_1.Queue([this.root]);
+            while (queue.size > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    if (cur.key === key)
+                        return cur;
+                    cur.left && queue.push(cur.left);
+                    cur.right && queue.push(cur.right);
+                }
+            }
+        }
+    }
+    /**
+     * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
+     * key, otherwise it returns the key itself.
+     * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
+     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be used when searching for a node by key. It has a default value of
+     * `IterationType.ITERATIVE`.
+     * @returns either the node corresponding to the given key if it is a valid node key, or the key
+     * itself if it is not a valid node key.
+     */
+    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+        return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+    }
     /**
      * The function `get` returns the first node value in a binary tree that matches the given property or key.
      * @param {BTNKey | N} identifier - The `identifier` parameter is the key or value of
@@ -547,18 +581,32 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`this.defaultOneParamCallback`) is used if no callback function is
+     * (`this._defaultOneParamCallback`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found value (of type V) or undefined if no node value is found.
      */
-    get(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
     }
+    /**
+     * Clear the binary tree, removing all nodes.
+     */
+    clear() {
+        this._setRoot(undefined);
+        this._size = 0;
+    }
+    /**
+     * Check if the binary tree is empty.
+     * @returns {boolean} - True if the binary tree is empty, false otherwise.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
      * up to the root node, with the option to reverse the order of the nodes.
@@ -572,6 +620,9 @@ class BinaryTree {
     getPathToRoot(beginRoot, isReverse = true) {
         // TODO to support get path through passing key
         const result = [];
+        beginRoot = this.ensureNotKey(beginRoot);
+        if (!beginRoot)
+            return result;
         while (beginRoot.parent) {
             // Array.push + Array.reverse is more efficient than Array.unshift
             // TODO may consider using Deque, so far this is not the performance bottleneck
@@ -593,13 +644,12 @@ class BinaryTree {
      * no leftmost node, it returns `null`.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.getNode(beginRoot);
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                if (!cur.left)
+                if (!this.isRealNode(cur.left))
                     return cur;
                 return _traverse(cur.left);
             };
@@ -608,7 +658,7 @@ class BinaryTree {
         else {
             // Indirect implementation of iteration using tail recursion optimization
             const _traverse = (0, utils_1.trampoline)((cur) => {
-                if (!cur.left)
+                if (!this.isRealNode(cur.left))
                     return cur;
                 return _traverse.cont(cur.left);
             });
@@ -628,11 +678,12 @@ class BinaryTree {
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
         // TODO support get right most by passing key in
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                if (!cur.right)
+                if (!this.isRealNode(cur.right))
                     return cur;
                 return _traverse(cur.right);
             };
@@ -641,7 +692,7 @@ class BinaryTree {
         else {
             // Indirect implementation of iteration using tail recursion optimization
             const _traverse = (0, utils_1.trampoline)((cur) => {
-                if (!cur.right)
+                if (!this.isRealNode(cur.right))
                     return cur;
                 return _traverse.cont(cur.right);
             });
@@ -659,6 +710,7 @@ class BinaryTree {
      */
     isSubtreeBST(beginRoot, iterationType = this.iterationType) {
         // TODO there is a bug
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return true;
         if (iterationType === types_1.IterationType.RECURSIVE) {
@@ -716,9 +768,8 @@ class BinaryTree {
      * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    subTreeTraverse(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.getNode(beginRoot);
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+        beginRoot = this.ensureNotKey(beginRoot);
         const ans = [];
         if (!beginRoot)
             return ans;
@@ -757,21 +808,46 @@ class BinaryTree {
         }
         return ans;
     }
-    isNode(node) {
+    /**
+     * 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.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isRealNode(node) {
         return node instanceof BinaryTreeNode && node.key.toString() !== 'NaN';
     }
+    /**
+     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
     isNIL(node) {
         return node instanceof BinaryTreeNode && node.key.toString() === 'NaN';
     }
+    /**
+     * 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.isNode(node) || node === null;
+        return this.isRealNode(node) || node === null;
+    }
+    /**
+     * The function "isNodeKey" checks if a potential key is a number.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNodeKey(potentialKey) {
+        return typeof potentialKey === 'number';
     }
     /**
      * 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.
      * @param callback - The `callback` parameter is a function that will be called on each node during
      * the depth-first search traversal. It takes a node as input and returns a value. The default value
-     * is `this.defaultOneParamCallback`, which is a callback function defined elsewhere in the code.
+     * 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 | undefined} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -782,7 +858,8 @@ class BinaryTree {
      * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    dfs(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE, includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE, includeNull = false) {
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
@@ -800,7 +877,7 @@ class BinaryTree {
                         else {
                             if (node && node.left)
                                 _traverse(node.left);
-                            this.isNode(node) && ans.push(callback(node));
+                            this.isRealNode(node) && ans.push(callback(node));
                             if (node && node.right)
                                 _traverse(node.right);
                         }
@@ -814,7 +891,7 @@ class BinaryTree {
                                 _traverse(node.right);
                         }
                         else {
-                            this.isNode(node) && ans.push(callback(node));
+                            this.isRealNode(node) && ans.push(callback(node));
                             if (node && node.left)
                                 _traverse(node.left);
                             if (node && node.right)
@@ -834,7 +911,7 @@ class BinaryTree {
                                 _traverse(node.left);
                             if (node && node.right)
                                 _traverse(node.right);
-                            this.isNode(node) && ans.push(callback(node));
+                            this.isRealNode(node) && ans.push(callback(node));
                         }
                         break;
                 }
@@ -892,7 +969,7 @@ class BinaryTree {
      * function on each node.
      * @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
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this._defaultOneParamCallback
      * @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.
@@ -901,7 +978,8 @@ class BinaryTree {
      * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
      */
-    bfs(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
@@ -968,10 +1046,11 @@ class BinaryTree {
      * level in a binary tree. Each inner array contains the return type of the provided callback
      * function `C` applied to the nodes at that level.
      */
-    listLevels(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-        if (!beginRoot)
-            return [];
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+        beginRoot = this.ensureNotKey(beginRoot);
         const levelsNodes = [];
+        if (!beginRoot)
+            return levelsNodes;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
                 if (!levelsNodes[level])
@@ -1022,9 +1101,12 @@ class BinaryTree {
      * @returns The function `getPredecessor` returns the predecessor node of the given node `node`.
      */
     getPredecessor(node) {
+        node = this.ensureNotKey(node);
+        if (!this.isRealNode(node))
+            return undefined;
         if (node.left) {
             let predecessor = node.left;
-            while (!predecessor || (predecessor.right && predecessor.right !== node)) {
+            while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
                 if (predecessor) {
                     predecessor = predecessor.right;
                 }
@@ -1043,6 +1125,9 @@ class BinaryTree {
      * if there is no successor, or `undefined` if the input `x` is `undefined`.
      */
     getSuccessor(x) {
+        x = this.ensureNotKey(x);
+        if (!x)
+            return undefined;
         if (x.right) {
             return this.getLeftMost(x.right);
         }
@@ -1058,7 +1143,7 @@ class BinaryTree {
      * algorithm and returns an array of values obtained by applying a callback function to each node.
      * @param callback - The `callback` parameter is a function that will be called on each node in the
      * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-     * default value for this parameter is `this.defaultOneParamCallback`.
+     * default value for this parameter is `this._defaultOneParamCallback`.
      * @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:
@@ -1067,7 +1152,8 @@ class BinaryTree {
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    morris(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
+    morris(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
+        beginRoot = this.ensureNotKey(beginRoot);
         if (beginRoot === null)
             return [];
         const ans = [];
@@ -1192,7 +1278,7 @@ class BinaryTree {
             }
         }
     }
-    defaultOneParamCallback = (node) => node.key;
+    _defaultOneParamCallback = (node) => node.key;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.
@@ -1200,15 +1286,20 @@ class BinaryTree {
      * @returns {N} - The destination node after the swap.
      */
     _swap(srcNode, destNode) {
-        const { key, value } = destNode;
-        const tempNode = this.createNode(key, value);
-        if (tempNode) {
-            destNode.key = srcNode.key;
-            destNode.value = srcNode.value;
-            srcNode.key = tempNode.key;
-            srcNode.value = tempNode.value;
+        srcNode = this.ensureNotKey(srcNode);
+        destNode = this.ensureNotKey(destNode);
+        if (srcNode && destNode) {
+            const { key, value } = destNode;
+            const tempNode = this.createNode(key, value);
+            if (tempNode) {
+                destNode.key = srcNode.key;
+                destNode.value = srcNode.value;
+                srcNode.key = tempNode.key;
+                srcNode.value = tempNode.value;
+            }
+            return destNode;
         }
-        return destNode;
+        return undefined;
     }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
@@ -1222,6 +1313,8 @@ class BinaryTree {
      * If the parent node is null, the function also returns undefined.
      */
     _addTo(newNode, parent) {
+        if (this.isNodeKey(parent))
+            parent = this.getNode(parent);
         if (parent) {
             // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
             // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
@@ -1259,7 +1352,16 @@ class BinaryTree {
         }
         this._root = v;
     }
+    /**
+     * The `print` function is used to display a binary tree structure in a visually appealing way.
+     * @param {N | null | undefined} root - The `root` parameter in the `print` function represents the
+     * root node of a binary tree. It can have one of the following types: `BTNKey`, `N`, `null`, or
+     * `undefined`. The default value is `this.root`, which suggests that `this.root` is the
+     */
     print(beginRoot = this.root) {
+        beginRoot = this.ensureNotKey(beginRoot);
+        if (!beginRoot)
+            return;
         const display = (root) => {
             const [lines, , ,] = _displayAux(root);
             for (const line of lines) {