bst-typed 1.47.5 → 1.47.7

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey } from '../../types';
+import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey, BTNodeEntry, BTNodeExemplar, BTNodeKeyOrNode } from '../../types';
 import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 /**
@@ -14,43 +14,15 @@ import { IBinaryTree } from '../../interfaces';
  * @template N - The type of the family relationship in the binary tree.
  */
 export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> {
-    /**
-     * The key associated with the node.
-     */
     key: BTNKey;
-    /**
-     * The value stored in the node.
-     */
     value?: V;
-    /**
-     * The parent node of the current node.
-     */
-    parent?: N | null;
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BTNKey} key - The key associated with the node.
-     * @param {V} value - The value stored in the node.
-     */
+    parent?: N;
     constructor(key: BTNKey, value?: V);
     protected _left?: N | null;
-    /**
-     * Get the left child node.
-     */
     get left(): N | null | undefined;
-    /**
-     * Set the left child node.
-     * @param {N | null | undefined} v - The left child node.
-     */
     set left(v: N | null | undefined);
     protected _right?: N | null;
-    /**
-     * Get the right child node.
-     */
     get right(): N | null | undefined;
-    /**
-     * Set the right child node.
-     * @param {N | null | undefined} v - The right child node.
-     */
     set right(v: N | null | undefined);
     /**
      * Get the position of the node within its family.
@@ -59,25 +31,31 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
     get familyPosition(): FamilyPosition;
 }
 /**
- * Represents a binary tree data structure.
- * @template N - The type of the binary tree's nodes.
+ * 1. Two Children Maximum: Each node has at most two children.
+ * 2. Left and Right Children: Nodes have distinct left and right children.
+ * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
+ * 4. Subtrees: Each child of a node forms the root of a subtree.
+ * 5. Leaf Nodes: Nodes without children are leaves.
+ * 6. Internal Nodes: Nodes with at least one child are internal.
+ * 7. Balanced Trees: The heights of the left and right subtrees of any node differ by no more than one.
+ * 8. Full Trees: Every node has either 0 or 2 children.
+ * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
 export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> implements IBinaryTree<V, N, TREE> {
-    options: BinaryTreeOptions;
+    iterationType: IterationType;
     /**
-     * Creates a new instance of BinaryTree.
-     * @param {BinaryTreeOptions} [options] - The options for the binary tree.
+     * The constructor function initializes a binary tree object with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * elements to be added to the binary tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary tree. In this case, it is of type
+     * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
+     * required.
      */
-    constructor(options?: BinaryTreeOptions);
+    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BinaryTreeOptions>);
     protected _root?: N | null;
-    /**
-     * Get the root node of the binary tree.
-     */
     get root(): N | null | undefined;
     protected _size: number;
-    /**
-     * Get the number of nodes in the binary tree.
-     */
     get size(): number;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
@@ -86,26 +64,51 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {N} - The newly created BinaryTreeNode.
      */
     createNode(key: BTNKey, value?: V): N;
-    createTree(options?: BinaryTreeOptions): TREE;
     /**
-     * Time Complexity: O(n)
+     * 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
+     * behavior of the `BinaryTree` class. It is of type `Partial<BinaryTreeOptions>`, which means that
+     * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
+     * @returns a new instance of a binary tree.
+     */
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
+    /**
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param kne - BTNodeExemplar<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.
+     * @returns a boolean value.
+     */
+    isEntry(kne: BTNodeExemplar<V, N>): kne is BTNodeEntry<V>;
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
+     */
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
+     *
+     * The `add` function adds a new node to a binary tree, either by key or by providing a node object.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be one of the following:
+     * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | null | undefined;
+    /**
+     * Time Complexity: O(k log n) - 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(n)
+     * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node with a key and value to a binary tree, or updates the value of
-     * an existing node with the same key.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The value to be associated with the key or node being added to the binary
-     * tree.
-     * @returns The function `add` returns a node (`N`) if it was successfully inserted into the binary
-     * tree, or `null` or `undefined` if the insertion was not successful.
+     * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
+     * current instance, and returns an array of the inserted nodes.
+     * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
+     * `BTNodeExemplar<V, N>` objects.
+     * @returns The function `addMany` returns an array of values, where each value is either of type
+     * `N`, `null`, or `undefined`.
      */
-    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | null | undefined;
+    addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (N | null | undefined)[];
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
@@ -114,34 +117,15 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes an array of keys or nodes and an optional array of values, and adds
-     * each key-value pair to a data structure.
-     * @param {(BTNKey | N |null | undefined)[]} keysOrNodes - An array of keys or nodes to be added to
-     * the binary search tree. Each element can be of type `BTNKey` (a key value), `N` (a node), `null`,
-     * or `undefined`.
-     * @param {(V | undefined)[]} [values] - The `values` parameter is an optional array of values that
-     * correspond to the keys or nodes being added. If provided, the values will be associated with the
-     * keys or nodes during the add operation.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
-     */
-    addMany(keysOrNodes: (BTNKey | N | null | undefined)[], values?: (V | undefined)[]): (N | null | undefined)[];
-    /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-     * Space Complexity: O(1)
+     * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
+     * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
+     * contain either `BTNodeExemplar` objects, keys, or entries.
      */
+    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<V, N>>): void;
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
-     *
-     * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
-     * @param {(BTNKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
-     * `BTNKey` or `N` values.
-     * @param {N[] | Array<V>} [values] - The `data` parameter is an optional array of values that will be assigned to
-     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
-     * array. Each value in the `data` array will be assigned to the
-     * @returns The method is returning a boolean value.
-     */
-    refill(keysOrNodes: (BTNKey | N | null | undefined)[], values?: (V | undefined)[]): boolean;
+     */
     delete<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C): BiTreeDeleteResult<N>[];
     delete<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C): BiTreeDeleteResult<N>[];
@@ -162,11 +146,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
-    getDepth(distNode: BTNKey | N | null | undefined, beginRoot?: BTNKey | N | null | undefined): number;
+    getDepth(distNode: BTNodeKeyOrNode<N>, beginRoot?: BTNodeKeyOrNode<N>): number;
     /**
      * 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(1)
      */
     /**
      * Time Complexity: O(n)
@@ -182,7 +165,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
+    getHeight(beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -201,10 +184,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * 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?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): number;
+    getMinHeight(beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): number;
     /**
      * 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)
@@ -217,16 +201,28 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
      * @returns a boolean value.
      */
-    isPerfectlyBalanced(beginRoot?: BTNKey | N | null | undefined): boolean;
-    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N[];
-    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
-    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): boolean;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
+    isPerfectlyBalanced(beginRoot?: BTNodeKeyOrNode<N>): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
+    has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
+    has<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n).
+     */
+    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
+    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -247,7 +243,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      */
     getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * 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 {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
@@ -257,10 +257,14 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNotKey(key: BTNKey | N | null | undefined, iterationType?: IterationType): N | null | undefined;
-    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
-    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType): V | undefined;
+    ensureNode(key: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
+    get<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N, N>>(identifier: N | null | undefined, callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
+    get<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): V | undefined;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -270,10 +274,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
     isEmpty(): boolean;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -288,10 +288,10 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * 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[]`).
      */
-    getPathToRoot(beginRoot: BTNKey | N | null | undefined, isReverse?: boolean): N[];
+    getPathToRoot(beginRoot: BTNodeKeyOrNode<N>, isReverse?: boolean): N[];
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -307,7 +307,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
+    getLeftMost(beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -327,9 +327,9 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): N | null | undefined;
+    getRightMost(beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType): N | null | undefined;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -344,7 +344,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot: BTNKey | N | null | undefined, iterationType?: IterationType | undefined): boolean;
+    isSubtreeBST(beginRoot: BTNodeKeyOrNode<N>, iterationType?: IterationType): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -360,10 +360,18 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType?: IterationType | undefined): boolean;
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    isBST(iterationType?: IterationType): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * 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.
@@ -390,15 +398,27 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
      */
     isNodeKey(potentialKey: any): potentialKey is number;
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNKey | N | null | undefined, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
     getPredecessor(node: N): N;
     /**
      * The function `getSuccessor` returns the next node in a binary tree given a current node.
@@ -407,10 +427,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * after the given node in the inorder traversal of the binary tree.
      */
     getSuccessor(x?: BTNKey | N | null): N | null | undefined;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -429,7 +445,11 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * `callback` function on each node in the binary tree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNKey | N | null | undefined): ReturnType<C>[];
+    morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -483,7 +503,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * 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?: BTNKey | N | null | undefined, options?: BinaryTreePrintOptions): void;
+    print(beginRoot?: BTNodeKeyOrNode<N>, options?: BinaryTreePrintOptions): void;
     protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _defaultOneParamCallback: (node: N) => number;
     /**
@@ -492,7 +512,16 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {N} destNode - The destination node to swap.
      * @returns {N} - The destination node after the swap.
      */
-    protected _swap(srcNode: BTNKey | N | null | undefined, destNode: BTNKey | N | null | undefined): N | undefined;
+    protected _swapProperties(srcNode: BTNodeKeyOrNode<N>, destNode: BTNodeKeyOrNode<N>): N | 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
+     * tree.
+     * @param {N} 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;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
@@ -504,7 +533,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * the binary tree. If neither the left nor right child is available, the function returns undefined.
      * If the parent node is null, the function also returns undefined.
      */
-    protected _addTo(newNode: N | null | undefined, parent: BTNKey | N | null | undefined): N | null | undefined;
+    protected _addTo(newNode: N | null | undefined, parent: BTNodeKeyOrNode<N>): N | null | undefined;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null,
      * it also sets the parent property of the value to undefined.