data-structure-typed 1.42.3 → 1.42.5

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

@@ -69,11 +69,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options?: BinaryTreeOptions);
-    protected _root: N | null;
+    protected _root: N | null | undefined;
     /**
      * Get the root node of the binary tree.
      */
-    get root(): N | null;
+    get root(): N | null | undefined;
     protected _size: number;
     /**
      * Get the number of nodes in the binary tree.
@@ -101,7 +101,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {V} value - The value for the new node (optional).
      * @returns {N | null | undefined} - The inserted node, or null if nothing was inserted, or undefined if the operation failed.
      */
-    add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined;
+    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | null | undefined;
     /**
      * The `addMany` function takes an array of binary tree node IDs or nodes, and optionally an array of corresponding data
      * values, and adds them to the binary tree.
@@ -112,7 +112,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * the value of the nodes will be `undefined`.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], values?: V[]): (N | null | undefined)[];
+    addMany(keysOrNodes: (BTNKey | null | undefined)[] | (N | null | undefined)[], values?: V[]): (N | null | undefined)[];
     /**
      * 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
@@ -122,27 +122,27 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * array. Each value in the `data` array will be assigned to the
      * @returns The method is returning a boolean value.
      */
-    refill(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: Array<V>): boolean;
+    refill(keysOrNodes: (BTNKey | null | undefined)[] | (N | null | undefined)[], data?: Array<V>): boolean;
     delete<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C): BinaryTreeDeletedResult<N>[];
-    delete<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BinaryTreeDeletedResult<N>[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeletedResult<N>[];
     /**
      * 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.
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
-    getDepth(distNode: BTNKey | N | null, beginRoot?: BTNKey | N | null): number;
+    getDepth(distNode: BTNKey | N | null | undefined, beginRoot?: BTNKey | N | null | undefined): number;
     /**
      * 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 `
@@ -151,38 +151,38 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNKey | N | null, iterationType?: IterationType): number;
+    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): number;
     /**
      * 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
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot?: N | null, iterationType?: IterationType): number;
+    getMinHeight(beginRoot?: N | null | undefined, iterationType?: IterationType): number;
     /**
      * 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.
      */
-    isPerfectlyBalanced(beginRoot?: N | null): boolean;
-    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C, beginRoot?: N | null, iterationType?: IterationType): boolean;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null, iterationType?: IterationType): V | undefined;
+    isPerfectlyBalanced(beginRoot?: N | null | undefined): boolean;
+    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null | undefined, iterationType?: IterationType): N[];
+    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): boolean;
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | null | undefined, iterationType?: IterationType): V | undefined;
     /**
      * 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.
@@ -197,7 +197,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     /**
      * 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
@@ -205,19 +205,19 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in a binary tree. If there is
      * no leftmost node, it returns `null`.
      */
-    getLeftMost(beginRoot?: BTNKey | N | null, iterationType?: IterationType): N | null;
+    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
      * 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:
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If the
      * `beginRoot` parameter is `null`, it returns `null`.
      */
-    getRightMost(beginRoot?: N | null, iterationType?: IterationType): N | null;
+    getRightMost(beginRoot?: N | null | undefined, iterationType?: IterationType): N | null | undefined;
     /**
      * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
      * @param {N} beginRoot - The `beginRoot` parameter is the root node of the binary tree that you want
@@ -227,7 +227,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns The function `isSubtreeBST` returns a boolean value.
      */
-    isSubtreeBST(beginRoot: N | null, iterationType?: IterationType): boolean;
+    isSubtreeBST(beginRoot: N | null | undefined, iterationType?: IterationType): boolean;
     /**
      * The function checks if a binary tree is a binary search tree.
      * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
@@ -237,18 +237,21 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a boolean value.
      */
     isBST(iterationType?: IterationType): boolean;
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    isNode(node: any): node is N;
+    isNIL(node: any): boolean;
+    isNodeOrNull(node: any): node is (N | null);
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * The function returns the predecessor node of a given node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree.
@@ -272,12 +275,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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.
      */
-    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null): ReturnType<C>[];
+    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null | undefined): ReturnType<C>[];
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.
@@ -287,7 +290,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
      * binary tree nodes in a specific order.
      */
-    [Symbol.iterator](node?: N | null): Generator<BTNKey, void, undefined>;
+    [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
     protected defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.
@@ -298,7 +301,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     protected _swap(srcNode: N, destNode: N): N;
     /**
      * 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.
@@ -307,12 +310,13 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * the binary tree. If neither the left nor right child is available, the function returns undefined.
      * If the parent node is null, the function also returns undefined.
      */
-    protected _addTo(newNode: N | null, parent: N): N | null | undefined;
+    protected _addTo(newNode: N | null | undefined, parent: N): N | null | undefined;
     /**
      * 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`.
      */
-    protected _setRoot(v: N | null): void;
+    protected _setRoot(v: N | null | undefined): void;
+    print(beginRoot?: N | null | undefined): void;
 }

package/dist/cjs/src/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,6 +1248,59 @@ 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;
 //# sourceMappingURL=binary-tree.js.map