heap-typed 1.49.4 → 1.49.6

package/src/data-structures/binary-tree/binary-tree.ts

@@ -14,24 +14,27 @@ import type {
   BinaryTreePrintOptions,
   BTNCallback,
   BTNEntry,
-  BTNExemplar,
-  BTNKeyOrNode,
   DFSOrderPattern,
   EntryCallback,
+  KeyOrNodeOrEntry,
   NodeDisplayLayout
 } from '../../types';
 import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
-import { IterableEntryBase } from "../base";
+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.
  */
-export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export class BinaryTreeNode<
+  K = any,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>
+> {
   key: K;
 
   value?: V;
@@ -97,21 +100,26 @@ export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N>
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
 
-export 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>
-
+export 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> {
-  iterationType = IterationType.ITERATIVE
+  iterationType = IterationType.ITERATIVE;
 
   /**
-   * The constructor function initializes a binary tree object with optional elements and options.
-   * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
-   * elements to be added to the binary tree.
+   * The constructor function initializes a binary tree object with optional nodes and options.
+   * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+   * nodes 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(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>) {
+  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>) {
     super();
     if (options) {
       const { iterationType, extractor } = options;
@@ -125,10 +133,10 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
 
     this._size = 0;
 
-    if (elements) this.addMany(elements);
+    if (nodes) this.addMany(nodes);
   }
 
-  protected _extractor = (key: K) => Number(key)
+  protected _extractor = (key: K) => Number(key);
 
   get extractor() {
     return this._extractor;
@@ -168,30 +176,21 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   }
 
   /**
-   * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-   * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V,N>`.
-   * @returns a boolean value indicating whether the exemplar is an instance of the class N.
-   */
-  isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N {
-    return exemplar instanceof BinaryTreeNode;
-  }
-
-  /**
-   * The function `exemplarToNode` converts an exemplar object into a node object.
-   * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
+   * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+   * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
    * @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 exemplar node. If no value
+   * `exemplarToNode` 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.
    */
-  exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | null | undefined {
-    if (exemplar === undefined) return;
+  exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): N | null | undefined {
+    if (keyOrNodeOrEntry === undefined) return;
 
     let node: N | null | undefined;
-    if (exemplar === null) {
+    if (keyOrNodeOrEntry === null) {
       node = null;
-    } else if (this.isEntry(exemplar)) {
-      const [key, value] = exemplar;
+    } else if (this.isEntry(keyOrNodeOrEntry)) {
+      const [key, value] = keyOrNodeOrEntry;
       if (key === undefined) {
         return;
       } else if (key === null) {
@@ -199,24 +198,112 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
       } else {
         node = this.createNode(key, value);
       }
-    } else if (this.isNode(exemplar)) {
-      node = exemplar;
-    } else if (this.isNotNodeInstance(exemplar)) {
-      node = this.createNode(exemplar, value);
+    } else if (this.isNode(keyOrNodeOrEntry)) {
+      node = keyOrNodeOrEntry;
+    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+      node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
     }
     return node;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(log n)
+   */
+
+  /**
+   * 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 {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+   * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
+   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+   * type of iteration to be used when searching for a node by key. It has a default value of
+   * `IterationType.ITERATIVE`.
+   * @returns either the node corresponding to the given key if it is a valid node key, or the key
+   * itself if it is not a valid node key.
+   */
+  ensureNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>,
+    iterationType = IterationType.ITERATIVE
+  ): N | null | undefined {
+    let res: N | null | undefined;
+    if (this.isRealNode(keyOrNodeOrEntry)) {
+      res = keyOrNodeOrEntry;
+    } else if (this.isEntry(keyOrNodeOrEntry)) {
+      if (keyOrNodeOrEntry[0] === null) res = null;
+      else if (keyOrNodeOrEntry[0] !== undefined) res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+    } else {
+      if (keyOrNodeOrEntry === null) res = null;
+      else if (keyOrNodeOrEntry !== undefined) res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+    }
+    return res;
+  }
+
+  /**
+   * 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.
+   */
+  isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N {
+    return keyOrNodeOrEntry instanceof BinaryTreeNode;
+  }
+
   /**
    * The function checks if a given value is an entry in a binary tree node.
-   * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+   * @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.
    * @returns a boolean value.
    */
-  isEntry(kne: BTNExemplar<K, V, N>): kne is BTNEntry<K, V> {
-    return Array.isArray(kne) && kne.length === 2;
+  isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is BTNEntry<K, V> {
+    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.
+   * @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 {
+    return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+  }
+
+  /**
+   * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
+   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * @returns a boolean value.
+   */
+  isNIL(node: KeyOrNodeOrEntry<K, V, N>) {
+    return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+  }
+
+  /**
+   * The function checks if a given node is a real node or null.
+   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * @returns a boolean value.
+   */
+  isNodeOrNull(node: KeyOrNodeOrEntry<K, V, N>): node is N | null {
+    return this.isRealNode(node) || node === null;
+  }
+
+  /**
+   * The function "isNotNodeInstance" checks if a potential key is a K.
+   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+   * data type.
+   * @returns a boolean value indicating whether the potentialKey is of type number or not.
+   */
+  isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
+    return !(potentialKey instanceof BinaryTreeNode);
   }
 
   /**
@@ -234,15 +321,15 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @param {V} [value] - The value to be inserted into the binary tree.
    * @returns The function `add` returns either a node (`N`), `null`, or `undefined`.
    */
-  add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | null | undefined {
+  add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean {
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
-    if (newNode === undefined) return;
+    if (newNode === undefined) return false;
 
     // If the tree is empty, directly set the new node as the root node
     if (!this.root) {
       this._root = newNode;
       this._size = 1;
-      return newNode;
+      return true;
     }
 
     const queue = new Queue<N>([this.root]);
@@ -256,7 +343,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
       // Check for duplicate keys when newNode is not null
       if (newNode !== null && cur.key === newNode.key) {
         this._replaceNode(cur, newNode);
-        return newNode; // If duplicate keys are found, no insertion is performed
+        return true; // If duplicate keys are found, no insertion is performed
       }
 
       // Record the first possible insertion location found
@@ -281,13 +368,12 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
         potentialParent.right = newNode;
       }
       this._size++;
-      return newNode;
+      return true;
     }
 
-    return undefined; // If the insertion position cannot be found, return undefined
+    return false; // If the insertion position cannot be found, return undefined
   }
 
-
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
@@ -298,22 +384,22 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    *
-   * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+   * 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 nodes - An iterable collection of BTNExemplar objects.
+   * @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.
    */
-  addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[] {
+  addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[] {
     // TODO not sure addMany not be run multi times
-    const inserted: (N | null | undefined)[] = [];
+    const inserted: boolean[] = [];
 
     let valuesIterator: Iterator<V | undefined> | undefined;
     if (values) {
       valuesIterator = values[Symbol.iterator]();
     }
 
-    for (const kne of nodes) {
+    for (const keyOrNodeOrEntry of keysOrNodesOrEntries) {
       let value: V | undefined | null = undefined;
 
       if (valuesIterator) {
@@ -323,26 +409,39 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
         }
       }
 
-      inserted.push(this.add(kne, value));
+      inserted.push(this.add(keyOrNodeOrEntry, value));
     }
 
     return inserted;
   }
 
-
   /**
-   * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+   * 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.
    */
 
-  refill(nodesOrKeysOrEntries: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): void {
+  /**
+   * Time Complexity: O(k * n)
+   * Space Complexity: O(1)
+   *
+   * 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>.
+   * @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 {
     this.clear();
-    this.addMany(nodesOrKeysOrEntries, values);
+    this.addMany(keysOrNodesOrEntries, values);
   }
 
   /**
-   * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+   * 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>[];
@@ -426,24 +525,24 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Space Complexity: O(1)
    *
    * The function calculates the depth of a given node in a binary tree.
-   * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+   * @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 `distNode` relative to the `beginRoot`.
+   * @returns the depth of the `dist` relative to the `beginRoot`.
    */
-  getDepth(distNode: BTNKeyOrNode<K, N>, beginRoot: BTNKeyOrNode<K, N> = this.root): number {
-    distNode = this.ensureNode(distNode);
+  getDepth(dist: KeyOrNodeOrEntry<K, V, N>, beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root): number {
+    dist = this.ensureNode(dist);
     beginRoot = this.ensureNode(beginRoot);
     let depth = 0;
-    while (distNode?.parent) {
-      if (distNode === beginRoot) {
+    while (dist?.parent) {
+      if (dist === beginRoot) {
         return depth;
       }
       depth++;
-      distNode = distNode.parent;
+      dist = dist.parent;
     }
     return depth;
   }
@@ -467,7 +566,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * values:
    * @returns the height of the binary tree.
    */
-  getHeight(beginRoot: BTNKeyOrNode<K, N> = this.root, iterationType = this.iterationType): number {
+  getHeight(beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
@@ -516,7 +615,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * 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: BTNKeyOrNode<K, N> = this.root, iterationType = this.iterationType): number {
+  getMinHeight(beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
@@ -576,7 +675,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * value of a binary tree node), `N` (a node of a binary tree), `null`, or `undefined`. If
    * @returns a boolean value.
    */
-  isPerfectlyBalanced(beginRoot: BTNKeyOrNode<K, N> = this.root): boolean {
+  isPerfectlyBalanced(beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root): boolean {
     return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
   }
 
@@ -589,7 +688,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     identifier: K,
     callback?: C,
     onlyOne?: boolean,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N[];
 
@@ -597,7 +696,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     identifier: N | null | undefined,
     callback?: C,
     onlyOne?: boolean,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N[];
 
@@ -605,7 +704,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     identifier: ReturnType<C>,
     callback: C,
     onlyOne?: boolean,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N[];
 
@@ -638,7 +737,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): N[] {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
@@ -686,26 +785,27 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   has<C extends BTNCallback<N, K>>(
     identifier: K,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N, N>>(
     identifier: N | null | undefined,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null | undefined,
     callback: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): boolean;
 
   /**
    * 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
@@ -727,7 +827,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): boolean {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
@@ -744,21 +844,21 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   getNode<C extends BTNCallback<N, K>>(
     identifier: K,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N | null | undefined;
 
   getNode<C extends BTNCallback<N, N>>(
     identifier: N | null | undefined,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N | null | undefined;
 
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): N | null | undefined;
 
@@ -786,7 +886,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
@@ -839,44 +939,24 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     }
   }
 
-  /**
-   * 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 {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
-   * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-   * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-   * type of iteration to be used when searching for a node by key. It has a default value of
-   * `IterationType.ITERATIVE`.
-   * @returns either the node corresponding to the given key if it is a valid node key, or the key
-   * itself if it is not a valid node key.
-   */
-  ensureNode(key: BTNKeyOrNode<K, N>, iterationType = IterationType.ITERATIVE): N | null | undefined {
-    return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-  }
-
   get<C extends BTNCallback<N, K>>(
     identifier: K,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N, N>>(
     identifier: N | null | undefined,
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType
   ): V | undefined;
 
@@ -905,7 +985,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): V | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
@@ -915,11 +995,14 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   }
 
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * Clear the binary tree, removing all nodes.
    */
   clear() {
@@ -928,6 +1011,14 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   }
 
   /**
+   * 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.
    */
@@ -949,7 +1040,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * 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: BTNKeyOrNode<K, N>, isReverse = true): N[] {
+  getPathToRoot(beginRoot: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
     // TODO to support get path through passing key
     const result: N[] = [];
     beginRoot = this.ensureNode(beginRoot);
@@ -968,7 +1059,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
 
   /**
    * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
@@ -986,7 +1077,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * is no leftmost node, it returns `null` or `undefined` depending on the input.
    */
   getLeftMost(
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
     beginRoot = this.ensureNode(beginRoot);
@@ -1032,7 +1123,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * is no rightmost node, it returns `null` or `undefined`, depending on the input.
    */
   getRightMost(
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
     // TODO support get right most by passing key in
@@ -1074,7 +1165,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * possible values:
    * @returns a boolean value.
    */
-  isSubtreeBST(beginRoot: BTNKeyOrNode<K, N>, iterationType = this.iterationType): boolean {
+  isBST(beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root, iterationType = this.iterationType): boolean {
     // TODO there is a bug
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return true;
@@ -1087,69 +1178,56 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
         return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
       };
 
-      return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+      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 stack = [];
-      let prev = Number.MIN_SAFE_INTEGER,
-        curr: N | null | undefined = beginRoot;
-      while (curr || stack.length > 0) {
-        while (curr) {
-          stack.push(curr);
-          curr = curr.left;
+      const checkBST = (checkMax = false) => {
+        const stack = [];
+        let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+        // @ts-ignore
+        let curr: N | null | undefined = 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;
         }
-        curr = stack.pop()!;
-        const numKey = this.extractor(curr.key);
-        if (!curr || prev >= numKey) return false;
-        prev = numKey;
-        curr = curr.right;
-      }
-      return true;
+        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 checks if a binary tree is a binary search tree.
-   * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
-   * be used when checking if the binary tree is a binary search tree (BST). It is an optional
-   * parameter with a default value of "this.iterationType". The value of "this.iterationType" is
-   * expected to be
-   * @returns a boolean value.
-   */
-  isBST(iterationType = this.iterationType): boolean {
-    if (this.root === null) return true;
-    return this.isSubtreeBST(this.root, iterationType);
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
+   * Time complexity: O(n)
+   * Space complexity: O(log n)
    */
 
   subTreeTraverse<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: undefined
   ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[];
@@ -1173,12 +1251,12 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * whether to include null values in the traversal. If `includeNull` is set to `true`, the
    * traversal will include null values, otherwise it will skip them.
    * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-   * the `callback` function on each node in the subtree. The type of the array elements is determined
+   * the `callback` function on each node in the subtree. The type of the array nodes is determined
    * by the return type of the `callback` function.
    */
   subTreeTraverse<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
@@ -1222,53 +1300,10 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     return ans;
   }
 
-  /**
-   * 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.
-   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-   * @returns a boolean value.
-   */
-  isRealNode(node: BTNExemplar<K, V, N>): node is N {
-    return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
-  }
-
-  /**
-   * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-   * @returns a boolean value.
-   */
-  isNIL(node: BTNExemplar<K, V, N>) {
-    return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
-  }
-
-  /**
-   * The function checks if a given node is a real node or null.
-   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-   * @returns a boolean value.
-   */
-  isNodeOrNull(node: BTNExemplar<K, V, N>): node is N | null {
-    return this.isRealNode(node) || node === null;
-  }
-
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof BinaryTreeNode)
-  }
-
   dfs<C extends BTNCallback<N>>(
     callback?: C,
     pattern?: DFSOrderPattern,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[];
@@ -1276,7 +1311,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   dfs<C extends BTNCallback<N>>(
     callback?: C,
     pattern?: DFSOrderPattern,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: undefined
   ): ReturnType<C>[];
@@ -1284,7 +1319,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   dfs<C extends BTNCallback<N | null | undefined>>(
     callback?: C,
     pattern?: DFSOrderPattern,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[];
@@ -1315,7 +1350,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   dfs<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType: IterationType = IterationType.ITERATIVE,
     includeNull = false
   ): ReturnType<C>[] {
@@ -1414,21 +1449,21 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
 
   bfs<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: undefined
   ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N | null | undefined>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[];
@@ -1456,7 +1491,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    */
   bfs<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
@@ -1515,21 +1550,21 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
 
   listLevels<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: undefined
   ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N | null | undefined>>(
     callback?: C,
-    beginRoot?: BTNKeyOrNode<K, N>,
+    beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[][];
@@ -1557,7 +1592,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    */
   listLevels<C extends BTNCallback<N | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
@@ -1637,7 +1672,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * after the given node in the inorder traversal of the binary tree.
    */
   getSuccessor(x?: K | N | null): N | null | undefined {
-
     x = this.ensureNode(x);
     if (!this.isRealNode(x)) return undefined;
 
@@ -1655,7 +1689,13 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
 
   /**
    * Time complexity: O(n)
-   * Space complexity: O(1)
+   * Space complexity: O(n)
+   */
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   *
    * 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
@@ -1668,13 +1708,13 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * 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 elements is determined
+   * `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 = this._defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
-    beginRoot: BTNKeyOrNode<K, N> = this.root
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
     if (beginRoot === null) return [];
@@ -1785,8 +1825,8 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `filter` function creates a new tree by iterating over the elements of the current tree and
-   * adding only the elements that satisfy the given predicate function.
+   * The `filter` function creates a new tree by iterating over the nodes of the current tree and
+   * adding only the nodes that satisfy the given predicate function.
    * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
    * `key`, and `index`. It should return a boolean value indicating whether the pair should be
    * included in the filtered tree or not.
@@ -1847,22 +1887,33 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   //
 
   /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * 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 |
    * 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: BTNKeyOrNode<K, N> = this.root, options?: BinaryTreePrintOptions): void {
+  print(beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root, options?: BinaryTreePrintOptions): void {
     const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;
 
-    if (opts.isShowUndefined) console.log(`U for undefined
+    if (opts.isShowUndefined)
+      console.log(`U for undefined
       `);
-    if (opts.isShowNull) console.log(`N for null
+    if (opts.isShowNull)
+      console.log(`N for null
       `);
-    if (opts.isShowRedBlackNIL) console.log(`S for Sentinel Node
+    if (opts.isShowRedBlackNIL)
+      console.log(`S for Sentinel Node
       `);
 
     const display = (root: N | null | undefined): void => {
@@ -1920,30 +1971,42 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     } else if (node !== null && node !== undefined) {
       // Display logic of normal nodes
 
-      const key = node.key, line = isNaN(this.extractor(key)) ? 'S' : this.extractor(key).toString(),
+      const key = node.key,
+        line = isNaN(this.extractor(key)) ? 'S' : this.extractor(key).toString(),
         width = line.length;
 
-      return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options))
-
+      return _buildNodeDisplay(
+        line,
+        width,
+        this._displayAux(node.left, options),
+        this._displayAux(node.right, options)
+      );
     } 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' : 'N',
+        width = line.length;
 
-      return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0])
+      return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
     }
 
     function _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
       const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
       const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-      const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
-        + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
-        + line
-        + '_'.repeat(Math.max(0, rightMiddle))
-        + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
-
-      const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
-        + ' '.repeat(width)
-        + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+      const firstLine =
+        ' '.repeat(Math.max(0, leftMiddle + 1)) +
+        '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1)) +
+        line +
+        '_'.repeat(Math.max(0, rightMiddle)) +
+        ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+
+      const secondLine =
+        (leftHeight > 0
+          ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1)
+          : ' '.repeat(leftWidth)) +
+        ' '.repeat(width) +
+        (rightHeight > 0
+          ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1)
+          : ' '.repeat(rightWidth));
 
       const mergedLines = [firstLine, secondLine];
 
@@ -1953,11 +2016,16 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
         mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
       }
 
-      return <NodeDisplayLayout>[mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+      return <NodeDisplayLayout>[
+        mergedLines,
+        leftWidth + width + rightWidth,
+        Math.max(leftHeight, rightHeight) + 2,
+        leftWidth + Math.floor(width / 2)
+      ];
     }
   }
 
-  protected _defaultOneParamCallback = (node: N | null | undefined) => node ? node.key : undefined;
+  protected _defaultOneParamCallback = (node: N | null | undefined) => (node ? node.key : undefined);
 
   /**
    * Swap the data of two nodes in the binary tree.
@@ -1965,7 +2033,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @param {N} destNode - The destination node to swap.
    * @returns {N} - The destination node after the swap.
    */
-  protected _swapProperties(srcNode: BTNKeyOrNode<K, N>, destNode: BTNKeyOrNode<K, N>): N | undefined {
+  protected _swapProperties(srcNode: KeyOrNodeOrEntry<K, V, N>, destNode: KeyOrNodeOrEntry<K, V, N>): N | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
 
@@ -2012,43 +2080,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     return newNode;
   }
 
-  /**
-   * 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
-   * the binary tree. It can be either a node object or `null`.
-   * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
-   * be added as a child.
-   * @returns either the left or right child node of the parent node, depending on which child is
-   * available for adding the new node. If a new node is added, the function also updates the size of
-   * 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: BTNKeyOrNode<K, N>): N | null | undefined {
-    if (this.isNotNodeInstance(parent)) parent = this.getNode(parent);
-
-    if (parent) {
-      // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
-      // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
-      if (parent.left === undefined) {
-        parent.left = newNode;
-        if (newNode) {
-          this._size = this.size + 1;
-        }
-        return parent.left;
-      } else if (parent.right === undefined) {
-        parent.right = newNode;
-        if (newNode) {
-          this._size = this.size + 1;
-        }
-        return parent.right;
-      } else {
-        return;
-      }
-    } else {
-      return;
-    }
-  }
-
   /**
    * 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.