min-heap-typed 1.50.0 → 1.50.2

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

@@ -15,25 +15,53 @@ const base_1 = require("../base");
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
- * @template N - The type of the family relationship in the binary tree.
+ * @template NODE - The type of the family relationship in the binary tree.
  */
 class BinaryTreeNode {
+    /**
+     * The constructor function initializes an object with a key and an optional value.
+     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+     * constructor. It is used to set the value of the "key" property of the object being created.
+     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+     * value associated with the key in the constructor.
+     */
     constructor(key, value) {
         this.key = key;
         this.value = value;
     }
+    /**
+     * The function returns the value of the `_left` property, which can be of type `NODE`, `null`, or
+     * `undefined`.
+     * @returns The left node of the current node is being returned. It can be either a NODE object,
+     * null, or undefined.
+     */
     get left() {
         return this._left;
     }
+    /**
+     * The function sets the left child of a node and updates its parent reference.
+     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * `undefined`.
+     */
     set left(v) {
         if (v) {
             v.parent = this;
         }
         this._left = v;
     }
+    /**
+     * The function returns the right node of a binary tree or null if it doesn't exist.
+     * @returns The method is returning the value of the `_right` property, which can be a `NODE` object,
+     * `null`, or `undefined`.
+     */
     get right() {
         return this._right;
     }
+    /**
+     * The function sets the right child of a node and updates its parent.
+     * @param {NODE | null | undefined} v - The parameter `v` can be of type `NODE`, `null`, or
+     * `undefined`.
+     */
     set right(v) {
         if (v) {
             v.parent = this;
@@ -92,12 +120,25 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (keysOrNodesOrEntries)
             this.addMany(keysOrNodesOrEntries);
     }
+    /**
+     * The function returns the value of the `_extractor` property.
+     * @returns The `_extractor` property is being returned.
+     */
     get extractor() {
         return this._extractor;
     }
+    /**
+     * The function returns the root node, which can be of type NODE, null, or undefined.
+     * @returns The method is returning the value of the `_root` property, which can be of type `NODE`,
+     * `null`, or `undefined`.
+     */
     get root() {
         return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
         return this._size;
     }
@@ -105,7 +146,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
      * @param {V} value - The value for the new node.
-     * @returns {N} - The newly created BinaryTreeNode.
+     * @returns {NODE} - The newly created BinaryTreeNode.
      */
     createNode(key, value) {
         return new BinaryTreeNode(key, value);
@@ -121,14 +162,14 @@ class BinaryTree extends base_1.IterableEntryBase {
         return new BinaryTree([], Object.assign({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
      * is provided, it will be `undefined`.
-     * @returns a value of type N (node), or null, or undefined.
+     * @returns a value of type NODE (node), or null, or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
         if (keyOrNodeOrEntry === undefined)
             return;
         let node;
@@ -168,7 +209,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
-     * @param {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+     * @param {K | NODE | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`,
      * `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
@@ -197,25 +238,21 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * 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,N>`.
-     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class N.
+     * @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) {
         return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,N> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and N, representing the value and node type respectively.
+     * @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;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * 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.
@@ -242,21 +279,21 @@ class BinaryTree extends base_1.IterableEntryBase {
         return this.isRealNode(node) || node === null;
     }
     /**
-     * Time Complexity O(log n) - O(n)
+     * Time Complexity O(n)
      * Space Complexity O(1)
      */
     /**
-     * Time Complexity O(log n) - O(n)
+     * Time Complexity O(n)
      * Space Complexity O(1)
      *
      * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
      * existing node with the same key.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param {V} [value] - The value to be inserted into the binary tree.
-     * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
+     * @returns The function `add` returns either a node (`NODE`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return false;
         // If the tree is empty, directly set the new node as the root node
@@ -302,19 +339,19 @@ class BinaryTree extends base_1.IterableEntryBase {
         return false; // If the insertion position cannot be found, return undefined
     }
     /**
-     * Time Complexity: O(k log n) - O(k * n)
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
-     * Time Complexity: O(k log n) - O(k * n)
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
      *
      * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
      * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `NODE`, `null`, or `undefined` values.
      */
     addMany(keysOrNodesOrEntries, values) {
         // TODO not sure addMany not be run multi times
@@ -346,7 +383,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The `refill` function clears the current data and adds new key-value pairs to the data structure.
      * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
-     * KeyOrNodeOrEntry<K, V, N>.
+     * KeyOrNodeOrEntry<K, V, NODE>.
      * @param [values] - The `values` parameter is an optional iterable that contains the values to be
      * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
      * the values will be associated with the corresponding keys or nodes or entries in the
@@ -357,6 +394,11 @@ class BinaryTree extends base_1.IterableEntryBase {
         this.addMany(keysOrNodesOrEntries, values);
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -369,7 +411,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @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.
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const deletedResult = [];
@@ -380,206 +422,51 @@ class BinaryTree extends base_1.IterableEntryBase {
         const curr = this.getNode(identifier, callback);
         if (!curr)
             return deletedResult;
-        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        let needBalanced = undefined;
+        const parent = curr === null || curr === void 0 ? void 0 : curr.parent;
+        let needBalanced;
         let orgCurrent = curr;
-        if (!curr.left) {
-            if (!parent) {
-                // Handle the case when there's only one root node
-                this._setRoot(null);
-            }
-            else {
-                const { familyPosition: fp } = curr;
-                if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
-                    parent.left = curr.right;
-                }
-                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
-                    parent.right = curr.right;
-                }
-                needBalanced = parent;
-            }
+        if (!curr.left && !curr.right && !parent) {
+            this._setRoot(undefined);
         }
-        else {
-            if (curr.left) {
-                const leftSubTreeRightMost = this.getRightMost(curr.left);
-                if (leftSubTreeRightMost) {
-                    const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                    orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
-                    if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-                            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-                        else
-                            parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-                        needBalanced = parentOfLeftSubTreeMax;
-                    }
+        else if (curr.left) {
+            const leftSubTreeRightMost = this.getRightMost(curr.left);
+            if (leftSubTreeRightMost) {
+                const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+                if (parentOfLeftSubTreeMax) {
+                    if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                        parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                    else
+                        parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                    needBalanced = parentOfLeftSubTreeMax;
                 }
             }
         }
-        this._size = this.size - 1;
-        deletedResult.push({ deleted: orgCurrent, needBalanced });
-        return deletedResult;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function calculates the depth of a given node in a binary tree.
-     * @param {K | N | null | undefined} dist - The `dist` parameter represents the node in
-     * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
-     * `undefined`.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
-     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
-     * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `dist` relative to the `beginRoot`.
-     */
-    getDepth(dist, beginRoot = this.root) {
-        dist = this.ensureNode(dist);
-        beginRoot = this.ensureNode(beginRoot);
-        let depth = 0;
-        while (dist === null || dist === void 0 ? void 0 : dist.parent) {
-            if (dist === beginRoot) {
-                return depth;
+        else if (parent) {
+            const { familyPosition: fp } = curr;
+            if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                parent.left = curr.right;
             }
-            depth++;
-            dist = dist.parent;
-        }
-        return depth;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
-     * iterative traversal.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the height. It can be of type
-     * `K`, `N`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
-     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
-     * height of the tree using a recursive approach or an iterative approach. It can have two possible
-     * values:
-     * @returns the height of the binary tree.
-     */
-    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
-            return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const _getMaxHeight = (cur) => {
-                if (!cur)
-                    return -1;
-                const leftHeight = _getMaxHeight(cur.left);
-                const rightHeight = _getMaxHeight(cur.right);
-                return Math.max(leftHeight, rightHeight) + 1;
-            };
-            return _getMaxHeight(beginRoot);
-        }
-        else {
-            const stack = [{ node: beginRoot, depth: 0 }];
-            let maxHeight = 0;
-            while (stack.length > 0) {
-                const { node, depth } = stack.pop();
-                if (node.left)
-                    stack.push({ node: node.left, depth: depth + 1 });
-                if (node.right)
-                    stack.push({ node: node.right, depth: depth + 1 });
-                maxHeight = Math.max(maxHeight, depth);
+            else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                parent.right = curr.right;
             }
-            return maxHeight;
-        }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The `getMinHeight` function calculates the minimum height of a binary tree using either a
-     * recursive or iterative approach.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
-     * type `K`, `N`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
-     * @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 = this.root, iterationType = this.iterationType) {
-        var _a, _b, _c;
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
-            return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const _getMinHeight = (cur) => {
-                if (!cur)
-                    return 0;
-                if (!cur.left && !cur.right)
-                    return 0;
-                const leftMinHeight = _getMinHeight(cur.left);
-                const rightMinHeight = _getMinHeight(cur.right);
-                return Math.min(leftMinHeight, rightMinHeight) + 1;
-            };
-            return _getMinHeight(beginRoot);
+            needBalanced = parent;
         }
         else {
-            const stack = [];
-            let node = beginRoot, last = null;
-            const depths = new Map();
-            while (stack.length > 0 || node) {
-                if (node) {
-                    stack.push(node);
-                    node = node.left;
-                }
-                else {
-                    node = stack[stack.length - 1];
-                    if (!node.right || last === node.right) {
-                        node = stack.pop();
-                        if (node) {
-                            const leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
-                            depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
-                            last = node;
-                            node = null;
-                        }
-                    }
-                    else
-                        node = node.right;
-                }
-            }
-            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+            this._setRoot(curr.right);
+            curr.right = undefined;
         }
+        this._size = this.size - 1;
+        deletedResult.push({ deleted: orgCurrent, needBalanced });
+        return deletedResult;
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(k + log n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
-     * height of the tree.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
-     * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
-     * @returns a boolean value.
-     */
-    isPerfectlyBalanced(beginRoot = this.root) {
-        return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
+     * Space Complexity: O(k + log n).
      *
      * The function `getNodes` retrieves nodes from a binary tree based on a given identifier and
      * callback function.
@@ -587,7 +474,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * that you want to search for in the binary tree. It can be of any type that is returned by the
      * callback function `C`. It can also be `null` or `undefined` if you don't want to search for a
      * specific value.
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` as
+     * @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
      * default
@@ -595,12 +482,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
      * node and return that node. If set to false (default), the function will continue iterating and
      * return all nodes that match the identifier.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the traversal. It can be either a key, a node object, or `null`/`undefined`. If
      * it is `null` or `undefined`, an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration used to
      * traverse the binary tree. It can have two possible values:
-     * @returns an array of nodes of type `N`.
+     * @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)
@@ -643,29 +530,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
-     *
-     * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
-     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
-     * that you want to search for in the binary tree. It can be of any type that is returned by the
-     * callback function `C`. It can also be `null` or `undefined` if you don't want to specify a
-     * specific identifier.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
-     * function should return a boolean value indicating whether the node should be included in the
-     * result or not.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
-     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node in the binary tree), a node object (`N`), or `null`/`undefined` to start the search from
-     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
-     * iteration to be performed on the binary tree. It is used to specify whether the iteration should
-     * 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)
-            callback = (node => node);
-        return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -678,14 +543,14 @@ class BinaryTree extends base_1.IterableEntryBase {
      * identifier.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for searching the binary tree. It can be either a key value, a node object, or `null`/`undefined`.
      * If `null` or `undefined` is passed, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for nodes in the binary tree. It determines the order in which the
      * nodes are visited during the search.
-     * @returns a value of type `N | null | undefined`.
+     * @returns a value of type `NODE | null | undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
@@ -708,7 +573,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @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
+     * @returns The function `getNodeByKey` returns a node (`NODE`) 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) {
@@ -740,6 +605,10 @@ class BinaryTree extends base_1.IterableEntryBase {
             }
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -753,9 +622,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * the binary tree. It is used to determine whether a node matches the given identifier. The callback
      * function should return a value that can be compared to the identifier to determine if it is a
      * match.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
      * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
-     * node), a node object of type `N`, or `null`/`undefined` to start the search from the root of
+     * node), a node object of type `NODE`, or `null`/`undefined` to start the search from the root of
      * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
      * be performed when searching for a node in the binary tree. It is an optional parameter with a
      * default value specified by `this.iterationType`.
@@ -769,46 +638,295 @@ class BinaryTree extends base_1.IterableEntryBase {
         return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     *
+     * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * that you want to search for in the binary tree. It can be of any type that is returned by the
+     * callback function `C`. It can also be `null` or `undefined` if you don't want to specify a
+     * specific identifier.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the binary tree. It is used to filter the nodes based on certain conditions. The `callback`
+     * function should return a boolean value indicating whether the node should be included in the
+     * result or not.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for the search in the binary tree. It can be specified as a `K` (a unique identifier for a
+     * node in the binary tree), a node object (`NODE`), or `null`/`undefined` to start the search from
+     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
+     * iteration to be performed on the binary tree. It is used to specify whether the iteration should
+     * 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)
+            callback = (node => node);
+        return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * Clear the binary tree, removing all nodes.
+     */
+    clear() {
+        this._setRoot(undefined);
+        this._size = 0;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * Check if the binary tree is empty.
+     * @returns {boolean} - True if the binary tree is empty, false otherwise.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the
+     * height of the tree.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for calculating the height and minimum height of a binary tree. It can be either a `K` (a key
+     * value of a binary tree node), `NODE` (a node of a binary tree), `null`, or `undefined`. If
+     * @returns a boolean value.
+     */
+    isPerfectlyBalanced(beginRoot = this.root) {
+        return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the root
+     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
+     * possible values:
+     * @returns a boolean value.
+     */
+    isBST(beginRoot = this.root, iterationType = this.iterationType) {
+        // TODO there is a bug
+        beginRoot = this.ensureNode(beginRoot);
+        if (!beginRoot)
+            return true;
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const dfs = (cur, min, max) => {
+                if (!cur)
+                    return true;
+                const numKey = this.extractor(cur.key);
+                if (numKey <= min || numKey >= max)
+                    return false;
+                return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
+            };
+            const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+            return isStandardBST || isInverseBST;
+        }
+        else {
+            const checkBST = (checkMax = false) => {
+                const stack = [];
+                let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+                // @ts-ignore
+                let curr = beginRoot;
+                while (curr || stack.length > 0) {
+                    while (curr) {
+                        stack.push(curr);
+                        curr = curr.left;
+                    }
+                    curr = stack.pop();
+                    const numKey = this.extractor(curr.key);
+                    if (!curr || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey))
+                        return false;
+                    prev = numKey;
+                    curr = curr.right;
+                }
+                return true;
+            };
+            const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
+            return isStandardBST || isInverseBST;
+        }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the depth of a given node in a binary tree.
+     * @param {K | NODE | null | undefined} dist - The `dist` parameter represents the node in
+     * the binary tree whose depth we want to find. It can be of type `K`, `NODE`, `null`, or
+     * `undefined`.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
+     * `NODE` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
+     * @returns the depth of the `dist` relative to the `beginRoot`.
+     */
+    getDepth(dist, beginRoot = this.root) {
+        dist = this.ensureNode(dist);
+        beginRoot = this.ensureNode(beginRoot);
+        let depth = 0;
+        while (dist === null || dist === void 0 ? void 0 : dist.parent) {
+            if (dist === beginRoot) {
+                return depth;
+            }
+            depth++;
+            dist = dist.parent;
+        }
+        return depth;
+    }
+    /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
-     * Clear the binary tree, removing all nodes.
+     * The function `getHeight` calculates the maximum height of a binary tree using either recursive or
+     * iterative traversal.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node of the binary tree from which we want to calculate the height. It can be of type
+     * `K`, `NODE`, `null`, or `undefined`. If not provided, it defaults to `this.root`.
+     * @param iterationType - The `iterationType` parameter is used to determine whether to calculate the
+     * height of the tree using a recursive approach or an iterative approach. It can have two possible
+     * values:
+     * @returns the height of the binary tree.
      */
-    clear() {
-        this._setRoot(undefined);
-        this._size = 0;
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
+        beginRoot = this.ensureNode(beginRoot);
+        if (!beginRoot)
+            return -1;
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const _getMaxHeight = (cur) => {
+                if (!cur)
+                    return -1;
+                const leftHeight = _getMaxHeight(cur.left);
+                const rightHeight = _getMaxHeight(cur.right);
+                return Math.max(leftHeight, rightHeight) + 1;
+            };
+            return _getMaxHeight(beginRoot);
+        }
+        else {
+            const stack = [{ node: beginRoot, depth: 0 }];
+            let maxHeight = 0;
+            while (stack.length > 0) {
+                const { node, depth } = stack.pop();
+                if (node.left)
+                    stack.push({ node: node.left, depth: depth + 1 });
+                if (node.right)
+                    stack.push({ node: node.right, depth: depth + 1 });
+                maxHeight = Math.max(maxHeight, depth);
+            }
+            return maxHeight;
+        }
     }
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
-     * Check if the binary tree is empty.
-     * @returns {boolean} - True if the binary tree is empty, false otherwise.
+     * The `getMinHeight` function calculates the minimum height of a binary tree using either a
+     * recursive or iterative approach.
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node of the binary tree from which we want to calculate the minimum height. It can be of
+     * type `K`, `NODE`, `null`, or `undefined`. If no value is provided, it defaults to `this.root`.
+     * @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.
      */
-    isEmpty() {
-        return this.size === 0;
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
+        var _a, _b, _c;
+        beginRoot = this.ensureNode(beginRoot);
+        if (!beginRoot)
+            return -1;
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const _getMinHeight = (cur) => {
+                if (!cur)
+                    return 0;
+                if (!cur.left && !cur.right)
+                    return 0;
+                const leftMinHeight = _getMinHeight(cur.left);
+                const rightMinHeight = _getMinHeight(cur.right);
+                return Math.min(leftMinHeight, rightMinHeight) + 1;
+            };
+            return _getMinHeight(beginRoot);
+        }
+        else {
+            const stack = [];
+            let node = beginRoot, last = null;
+            const depths = new Map();
+            while (stack.length > 0 || node) {
+                if (node) {
+                    stack.push(node);
+                    node = node.left;
+                }
+                else {
+                    node = stack[stack.length - 1];
+                    if (!node.right || last === node.right) {
+                        node = stack.pop();
+                        if (node) {
+                            const leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
+                            last = node;
+                            node = null;
+                        }
+                    }
+                    else
+                        node = node.right;
+                }
+            }
+            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+        }
     }
     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * /
+  
+     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
-     * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
+     * @param {K | NODE | null | undefined} beginNode - The `beginRoot` parameter represents the
+     * starting node from which you want to find the path to the root. It can be of type `K`, `NODE`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
      * resulting path should be reversed or not. If `isReverse` is set to `true`, the path will be
      * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
-     * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
+     * @returns The function `getPathToRoot` returns an array of nodes (`NODE[]`).
      */
     getPathToRoot(beginNode, isReverse = true) {
         // TODO to support get path through passing key
@@ -835,12 +953,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `getLeftMost` returns the leftmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | 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 `K` (a key value), `N` (a
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting point
+     * for finding the leftmost node in a binary tree. It can be either a `K` (a key value), `NODE` (a
      * node), `null`, or `undefined`. If not provided, it defaults to `this.root`,
      * @param iterationType - The `iterationType` parameter is used to determine the type of iteration to
      * be performed when finding the leftmost node in a binary tree. It can have two possible values:
-     * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
+     * @returns The function `getLeftMost` returns the leftmost node (`NODE`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
@@ -875,13 +993,13 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `getRightMost` returns the rightmost node in a binary tree, either recursively or
      * iteratively.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node from which we want to find the rightmost node. It can be of type `K`, `N`,
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node from which we want to find the rightmost node. It can be of type `K`, `NODE`,
      * `null`, or `undefined`. If not provided, it defaults to `this.root`, which is a property of the
      * current object.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when finding the rightmost node. It can have one of two values:
-     * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
+     * @returns The function `getRightMost` returns the rightmost node (`NODE`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
@@ -912,60 +1030,61 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `isSubtreeBST` checks if a given binary tree is a valid binary search tree.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the root
-     * node of the binary search tree (BST) that you want to check if it is a subtree of another BST.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when checking if a subtree is a binary search tree (BST). It can have two
-     * possible values:
-     * @returns a boolean value.
+     * The function returns the predecessor of a given node in a tree.
+     * @param {NODE} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
-    isBST(beginRoot = this.root, iterationType = this.iterationType) {
-        // TODO there is a bug
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
-            return true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const dfs = (cur, min, max) => {
-                if (!cur)
-                    return true;
-                const numKey = this.extractor(cur.key);
-                if (numKey <= min || numKey >= max)
-                    return false;
-                return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
-            };
-            const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-            const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
-            return isStandardBST || isInverseBST;
+    getPredecessor(node) {
+        if (this.isRealNode(node.left)) {
+            let predecessor = node.left;
+            while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
+                if (this.isRealNode(predecessor)) {
+                    predecessor = predecessor.right;
+                }
+            }
+            return predecessor;
         }
         else {
-            const checkBST = (checkMax = false) => {
-                const stack = [];
-                let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
-                // @ts-ignore
-                let curr = beginRoot;
-                while (curr || stack.length > 0) {
-                    while (curr) {
-                        stack.push(curr);
-                        curr = curr.left;
-                    }
-                    curr = stack.pop();
-                    const numKey = this.extractor(curr.key);
-                    if (!curr || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey))
-                        return false;
-                    prev = numKey;
-                    curr = curr.right;
-                }
-                return true;
-            };
-            const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
-            return isStandardBST || isInverseBST;
+            return node;
+        }
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getSuccessor` returns the next node in a binary tree given a current node.
+     * @param {K | NODE | null} [x] - The parameter `x` can be of type `K`, `NODE`, or `null`.
+     * @returns the successor of the given node or key. The successor is the node that comes immediately
+     * after the given node in the inorder traversal of the binary tree.
+     */
+    getSuccessor(x) {
+        x = this.ensureNode(x);
+        if (!this.isRealNode(x))
+            return undefined;
+        if (this.isRealNode(x.right)) {
+            return this.getLeftMost(x.right);
+        }
+        let y = x.parent;
+        while (this.isRealNode(y) && x === y.right) {
+            x = y;
+            y = y.parent;
         }
+        return y;
     }
     /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     * /
+  
+     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      *
@@ -973,11 +1092,11 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specified pattern and iteration type, and returns an array of values obtained from applying a
      * callback function to each visited node.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree during the depth-first search. It takes a single parameter, which can be of type `N`,
+     * the tree during the depth-first search. It takes a single parameter, which can be of type `NODE`,
      * `null`, or `undefined`, and returns a value of any type. The default value for this parameter is
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are traversed during the depth-first search. It can have one of the following values:
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the depth-first search traversal. It can be specified as a key, a node object, or
      * `null`/`undefined`. If not provided, the `beginRoot` will default to the root node of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
@@ -1094,6 +1213,10 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1103,7 +1226,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the breadth-first search traversal. It takes a single parameter, which is the current node being
      * visited, and returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
      * starting node for the breadth-first search traversal. It can be specified as a key, a node object,
      * or `null`/`undefined` to indicate the root of the tree. If not provided, the `root` property of
      * the class is used as
@@ -1167,6 +1290,10 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1175,10 +1302,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * a binary tree and contains the values returned by a callback function applied to the nodes at that
      * level.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter, which can be of type `N`, `null`, or `undefined`, and
+     * the tree. It takes a single parameter, which can be of type `NODE`, `null`, or `undefined`, and
      * returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node for traversing the tree. It can be either a node object (`N`), a key value
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * starting node for traversing the tree. It can be either a node object (`NODE`), a key value
      * (`K`), `null`, or `undefined`. If not provided, it defaults to the root node of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
      * performed on the tree. It can have two possible values:
@@ -1237,53 +1364,6 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return levelsNodes;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function returns the predecessor of a given node in a tree.
-     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
-     * tree.
-     * @returns the predecessor of the given 'node'.
-     */
-    getPredecessor(node) {
-        if (this.isRealNode(node.left)) {
-            let predecessor = node.left;
-            while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
-                if (this.isRealNode(predecessor)) {
-                    predecessor = predecessor.right;
-                }
-            }
-            return predecessor;
-        }
-        else {
-            return node;
-        }
-    }
-    /**
-     * The function `getSuccessor` returns the next node in a binary tree given a current node.
-     * @param {K | N | null} [x] - The parameter `x` can be of type `K`, `N`, or `null`.
-     * @returns the successor of the given node or key. The successor is the node that comes immediately
-     * after the given node in the inorder traversal of the binary tree.
-     */
-    getSuccessor(x) {
-        x = this.ensureNode(x);
-        if (!this.isRealNode(x))
-            return undefined;
-        if (this.isRealNode(x.right)) {
-            return this.getLeftMost(x.right);
-        }
-        let y = x.parent;
-        while (this.isRealNode(y) && x === y.right) {
-            x = y;
-            y = y.parent;
-        }
-        return y;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1295,12 +1375,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It takes a single parameter of type `N` (the type of the nodes in the tree) and returns
+     * the tree. It takes a single parameter of type `NODE` (the type of the nodes in the tree) and returns
      * a value of any type.
      * @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 {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
+     * @param {K | NODE | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
@@ -1406,7 +1486,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     clone() {
         const cloned = this.createTree();
-        this.bfs(node => cloned.add([node.key, node.value]));
+        this.bfs(node => {
+            if (node === null)
+                cloned.add(null);
+            else
+                cloned.add([node.key, node.value]);
+        }, this.root, this.iterationType, true);
         return cloned;
     }
     /**
@@ -1483,7 +1568,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(n)
      *
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
+     * @param {K | NODE | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | NODE | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
@@ -1497,7 +1582,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             console.log(`U for undefined
       `);
         if (opts.isShowNull)
-            console.log(`N for null
+            console.log(`NODE for null
       `);
         if (opts.isShowRedBlackNIL)
             console.log(`S for Sentinel Node
@@ -1510,6 +1595,15 @@ class BinaryTree extends base_1.IterableEntryBase {
         };
         display(beginRoot);
     }
+    /**
+     * The function `_getIterator` is a protected generator function that returns an iterator for the
+     * key-value pairs in a binary search tree.
+     * @param node - The `node` parameter represents the current node in the binary search tree. It is an
+     * optional parameter with a default value of `this.root`, which means if no node is provided, the
+     * root node of the tree will be used as the starting point for iteration.
+     * @returns The function `_getIterator` returns an `IterableIterator` of key-value pairs `[K, V |
+     * undefined]`.
+     */
     *_getIterator(node = this.root) {
         if (!node)
             return;
@@ -1538,6 +1632,20 @@ class BinaryTree extends base_1.IterableEntryBase {
             }
         }
     }
+    /**
+     * The `_displayAux` function is responsible for generating the display layout of a binary tree node,
+     * taking into account various options such as whether to show null, undefined, or NaN nodes.
+     * @param {NODE | null | undefined} node - The `node` parameter represents a node in a binary tree.
+     * It can be of type `NODE`, `null`, or `undefined`.
+     * @param {BinaryTreePrintOptions} options - The `options` parameter is an object that contains the
+     * following properties:
+     * @returns The function `_displayAux` returns a `NodeDisplayLayout` which is an array containing the
+     * following elements:
+     * 1. `mergedLines`: An array of strings representing the lines of the node display.
+     * 2. `totalWidth`: The total width of the node display.
+     * 3. `totalHeight`: The total height of the node display.
+     * 4. `middleIndex`: The index of the middle character
+     */
     _displayAux(node, options) {
         const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
         const emptyDisplayLayout = [['─'], 1, 0, 0];
@@ -1558,7 +1666,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else {
             // For cases where none of the conditions are met, null, undefined, and NaN nodes are not displayed
-            const line = node === undefined ? 'U' : 'N', width = line.length;
+            const line = node === undefined ? 'U' : 'NODE', width = line.length;
             return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
         }
         function _buildNodeDisplay(line, width, left, right) {
@@ -1592,9 +1700,9 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * Swap the data of two nodes in the binary tree.
-     * @param {N} srcNode - The source node to swap.
-     * @param {N} destNode - The destination node to swap.
-     * @returns {N} - The destination node after the swap.
+     * @param {NODE} srcNode - The source node to swap.
+     * @param {NODE} destNode - The destination node to swap.
+     * @returns {NODE} - The destination node after the swap.
      */
     _swapProperties(srcNode, destNode) {
         srcNode = this.ensureNode(srcNode);
@@ -1614,9 +1722,9 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * The function replaces an old node with a new node in a binary tree.
-     * @param {N} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * @param {NODE} oldNode - The oldNode parameter represents the node that needs to be replaced in the
      * tree.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * tree.
      * @returns The method is returning the newNode.
      */
@@ -1640,8 +1748,8 @@ class BinaryTree extends base_1.IterableEntryBase {
     /**
      * 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 | undefined} v - The parameter `v` is of type `N | null | undefined`, which means it can either be of
-     * type `N` or `null`.
+     * @param {NODE | null | undefined} v - The parameter `v` is of type `NODE | null | undefined`, which means it can either be of
+     * type `NODE` or `null`.
      */
     _setRoot(v) {
         if (v) {