min-heap-typed 1.50.1 → 1.50.2

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

@@ -12,19 +12,47 @@ import { IterableEntryBase } from '../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.
  */
-export declare class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
     key: K;
     value?: V;
-    parent?: N;
+    parent?: NODE;
+    /**
+     * 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: K, value?: V);
-    protected _left?: N | null;
-    get left(): N | null | undefined;
-    set left(v: N | null | undefined);
-    protected _right?: N | null;
-    get right(): N | null | undefined;
-    set right(v: N | null | undefined);
+    protected _left?: NODE | null;
+    /**
+     * 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(): NODE | null | undefined;
+    /**
+     * 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: NODE | null | undefined);
+    protected _right?: NODE | null;
+    /**
+     * 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(): NODE | null | undefined;
+    /**
+     * 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: NODE | null | undefined);
     /**
      * Get the position of the node within its family.
      * @returns {FamilyPosition} - The family position of the node.
@@ -38,7 +66,7 @@ export declare class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
-export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, N, TREE> {
+export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, NODE, TREE> = BinaryTree<K, V, NODE, BinaryTreeNested<K, V, NODE>>> extends IterableEntryBase<K, V | undefined> implements IBinaryTree<K, V, NODE, TREE> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
@@ -49,20 +77,33 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: BinaryTreeOptions<K>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BinaryTreeOptions<K>);
     protected _extractor: (key: K) => number;
+    /**
+     * The function returns the value of the `_extractor` property.
+     * @returns The `_extractor` property is being returned.
+     */
     get extractor(): (key: K) => number;
-    protected _root?: N | null;
-    get root(): N | null | undefined;
+    protected _root?: NODE | null;
+    /**
+     * 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(): NODE | null | undefined;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     /**
      * 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: K, value?: V): N;
+    createNode(key: K, value?: V): NODE;
     /**
      * The function creates a binary tree with the given options.
      * @param [options] - The `options` parameter is an optional object that allows you to customize the
@@ -72,14 +113,14 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      */
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
     /**
-     * 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: KeyOrNodeOrEntry<K, V, N>, value?: V): N | null | undefined;
+    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -90,7 +131,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * 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
@@ -98,74 +139,70 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * 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: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,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: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is BTNEntry<K, V>;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
+    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isRealNode(node: KeyOrNodeOrEntry<K, V, N>): node is N;
+    isRealNode(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE;
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNIL(node: KeyOrNodeOrEntry<K, V, N>): boolean;
+    isNIL(node: KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * The function checks if a given node is a real node or null.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, N>): node is N | null;
+    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is 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: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
-     * 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: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
+    addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -177,81 +214,73 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * 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
      * `keysOrNodesOrEntries` iterable
      */
-    refill(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): void;
-    /**
-     * Time Complexity: O(k * n)
-     * Space Complexity: O(1)
-     * "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-     */
-    delete<C extends BTNCallback<N, K>>(identifier: K, callback?: C): BinaryTreeDeleteResult<N>[];
-    delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeleteResult<N>[];
+    refill(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): void;
+    delete<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C): BinaryTreeDeleteResult<NODE>[];
+    delete<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C): BinaryTreeDeleteResult<NODE>[];
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C): BinaryTreeDeleteResult<NODE>[];
+    getNodes<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    getNode<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * 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`.
+     * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
+     * recursive or iterative iteration.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to find the node with the matching key value.
+     * @param iterationType - The `iterationType` parameter is used to determine whether the search for
+     * the node with the given key should be performed iteratively or recursively. It has two possible
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getDepth(dist: KeyOrNodeOrEntry<K, V, N>, beginRoot?: KeyOrNodeOrEntry<K, V, N>): number;
+    getNodeByKey(key: K, iterationType?: IterationType): NODE | undefined;
+    get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
+    has<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
-     * Time Complexity: O(n)
+     * 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)
      *
-     * 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.
+     * Clear the binary tree, removing all nodes.
      */
-    getHeight(beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): number;
+    clear(): void;
     /**
-     * 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(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
-     * 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.
+     * Check if the binary tree is empty.
+     * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
-    getMinHeight(beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): number;
+    isEmpty(): boolean;
     /**
      * 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)
@@ -259,93 +288,104 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * 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
+     * @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), `N` (a node of a binary tree), `null`, or `undefined`. If
+     * value of a binary tree node), `NODE` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: KeyOrNodeOrEntry<K, V, N>): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
-    getNodes<C extends BTNCallback<N, K>>(identifier: K, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N[];
+    isPerfectlyBalanced(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n).
+     * Space Complexity: O(1)
      */
-    has<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
-     * Space 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 | 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.
      */
-    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
+    isBST(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      *
-     * The function `getNodeByKey` searches for a node in a binary tree by its key, using either
-     * recursive or iterative iteration.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to find the node with the matching key value.
-     * @param iterationType - The `iterationType` parameter is used to determine whether the search for
-     * the node with the given key should be performed iteratively or recursively. It has two possible
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
+     * 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`.
      */
-    getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
-    get<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): V | undefined;
+    getDepth(dist: KeyOrNodeOrEntry<K, V, NODE>, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): number;
     /**
-     * Time Complexity: O(1)
+     * 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(): void;
+    getHeight(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
-     * 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(): boolean;
+    getMinHeight(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
     /**
+     * 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: KeyOrNodeOrEntry<K, V, N>, isReverse?: boolean): N[];
+    getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -356,15 +396,15 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * 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?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
+    getLeftMost(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -375,47 +415,30 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * 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?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | null | undefined;
+    getRightMost(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(log n)
      * 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.
-     */
-    isBST(beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): boolean;
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * 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'.
      */
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    getPredecessor(node: NODE): NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -424,19 +447,18 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * 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: N): N;
-    /**
      * 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`.
+     * @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?: K | N | null): N | null | undefined;
+    getSuccessor(x?: K | NODE | null): NODE | null | undefined;
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -448,19 +470,19 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * 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
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>): ReturnType<C>[];
+    morris<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -523,36 +545,59 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * 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.
      */
-    print(beginRoot?: KeyOrNodeOrEntry<K, V, N>, options?: BinaryTreePrintOptions): void;
-    protected _getIterator(node?: N | null | undefined): IterableIterator<[K, V | undefined]>;
-    protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
-    protected _defaultOneParamCallback: (node: N | null | undefined) => K | undefined;
+    print(beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): void;
+    /**
+     * 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]`.
+     */
+    protected _getIterator(node?: NODE | null | undefined): IterableIterator<[K, V | undefined]>;
+    /**
+     * 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
+     */
+    protected _displayAux(node: NODE | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
+    protected _defaultOneParamCallback: (node: NODE | null | undefined) => K | undefined;
     /**
      * 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.
      */
-    protected _swapProperties(srcNode: KeyOrNodeOrEntry<K, V, N>, destNode: KeyOrNodeOrEntry<K, V, N>): N | undefined;
+    protected _swapProperties(srcNode: KeyOrNodeOrEntry<K, V, NODE>, destNode: KeyOrNodeOrEntry<K, V, NODE>): NODE | undefined;
     /**
      * 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.
      */
-    protected _replaceNode(oldNode: N, newNode: N): N;
+    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
     /**
      * 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`.
      */
-    protected _setRoot(v: N | null | undefined): void;
+    protected _setRoot(v: NODE | null | undefined): void;
 }