diff --git a/src/data-structures/binary-tree/avl-tree-counter.ts b/src/data-structures/binary-tree/avl-tree-counter.ts
index 314d621..08d2c75 100644
--- a/src/data-structures/binary-tree/avl-tree-counter.ts
+++ b/src/data-structures/binary-tree/avl-tree-counter.ts
@@ -9,15 +9,15 @@ import type {
   AVLTreeCounterOptions,
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep,
   EntryCallback,
-  IterationType,
-  OptNodeOrNull
+  IterationType
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
 export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
+  override parent?: AVLTreeCounterNode<K, V> = undefined;
+
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -33,28 +33,26 @@ export class AVLTreeCounterNode<K = any, V = any> extends AVLTreeNode<K, V> {
     this.count = count;
   }
 
-  override parent?: AVLTreeCounterNode<K, V> = undefined;
+  override _left?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get left(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set left(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeCounterNode<K, V>> = undefined;
+  override _right?: AVLTreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeCounterNode<K, V>> {
+  override get right(): AVLTreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeCounterNode<K, V>>) {
+  override set right(v: AVLTreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -78,7 +76,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * `compareValues` functions to define custom comparison logic for keys and values, respectively.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeCounterNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeCounterOptions<K, V, R>
   ) {
     super([], options);
@@ -145,12 +145,14 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
 
   /**
    * The function checks if the input is an instance of AVLTreeCounterNode.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeCounterNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeCounterNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeCounterNode;
   }
 
@@ -160,9 +162,9 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the add method of a TypeScript class to add a new node to a data structure
    * and update the count.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
    * `keyNodeOrEntry` parameter can accept a value of type `R`, which can be any type. It
-   * can also accept a value of type `BTNRep<K, V, AVLTreeCounterNode<K, V>>`, which represents a key, node,
+   * can also accept a value of type `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`, which represents a key, node,
    * entry, or raw element
    * @param {V} [value] - The `value` parameter represents the value associated with the key in the
    * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -171,7 +173,11 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * be added once. However, you can specify a different value for `count` if you want to add
    * @returns a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>, value?: V, count = 1): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V,
+    count = 1
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     if (newNode === undefined) return false;
 
@@ -189,7 +195,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    *
    * The function overrides the delete method in a binary tree data structure, handling deletion of
    * nodes and maintaining balance in the tree.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
    * parameter in the `delete` method is used to specify the condition for deleting a node from the
    * binary tree. It can be a key, node, or entry that determines which
    * node(s) should be deleted.
@@ -203,7 +209,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * deleted node and whether balancing is needed in the tree.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     ignoreCount = false
   ): BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<AVLTreeCounterNode<K, V>>[] = [];
@@ -276,6 +282,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(log n)
+   *
    * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
    * tree using either a recursive or iterative approach.
    * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
@@ -374,8 +381,8 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
   /**
    * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
    * a node object.
-   * @param {BTNRep<K, V, AVLTreeCounterNode<K, V>>} keyNodeOrEntry - The
-   * `keyNodeOrEntry` parameter can be of type `R` or `BTNRep<K, V, AVLTreeCounterNode<K, V>>`.
+   * @param {K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
+   * `keyNodeOrEntry` parameter can be of type `R` or `K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
    * `override` function. It represents the value associated with the key in the data structure. If no
    * value is provided, it will default to `undefined`.
@@ -384,7 +391,7 @@ export class AVLTreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR
    * @returns either a AVLTreeCounterNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, AVLTreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | AVLTreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): [AVLTreeCounterNode<K, V> | undefined, V | undefined] {
diff --git a/src/data-structures/binary-tree/avl-tree-multi-map.ts b/src/data-structures/binary-tree/avl-tree-multi-map.ts
index 141594a..d1e819b 100644
--- a/src/data-structures/binary-tree/avl-tree-multi-map.ts
+++ b/src/data-structures/binary-tree/avl-tree-multi-map.ts
@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { AVLTreeMultiMapOptions, BTNOptKeyOrNull, BTNRep, OptNodeOrNull } from '../../types';
+import { AVLTreeMultiMapOptions, BTNOptKeyOrNull } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
+  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -23,28 +25,26 @@ export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
     super(key, value);
   }
 
-  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
+  override _left?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get left(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set left(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
+  override _right?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get right(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set right(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -71,7 +71,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * additional options for configuring the AVLTreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeMultiMapOptions<K, V[], R>
   ) {
     super([], { ...options, isMapMode: true });
@@ -117,7 +119,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
     return new AVLTreeMultiMapNode<K, V>(key, []);
   }
 
-  override add(node: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>>): boolean;
+  override add(
+    node: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -127,7 +131,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
    * tree multi-map.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
    * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
    * `values`
@@ -137,7 +141,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * @returns The `override add` method is returning a boolean value, which indicates whether the
    * addition operation was successful or not.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
@@ -180,7 +187,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
    * structure and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
    * pair in the AVLTreeMultiMapNode, or just the key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -191,7 +198,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
    * the value was not found in the array, it returns `false`.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);
diff --git a/src/data-structures/binary-tree/avl-tree.ts b/src/data-structures/binary-tree/avl-tree.ts
index 741edfc..ca73888 100644
--- a/src/data-structures/binary-tree/avl-tree.ts
+++ b/src/data-structures/binary-tree/avl-tree.ts
@@ -6,17 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type {
-  AVLTreeOptions,
-  BinaryTreeDeleteResult,
-  BSTNOptKeyOrNode,
-  BTNRep,
-  EntryCallback,
-  OptNodeOrNull
-} from '../../types';
+import type { AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
+  override parent?: AVLTreeNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor function initializes an instance with a key and an optional value.
    * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
@@ -30,28 +25,26 @@ export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
     super(key, value);
   }
 
-  override parent?: AVLTreeNode<K, V> = undefined;
+  override _left?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get left(): AVLTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set left(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
+  override _right?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get right(): AVLTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set right(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -76,7 +69,8 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
    * in an iterable format.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+   * iterable that can contain either `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined ` objects or `R` objects. It is
    * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
    * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
    * R>`. It is an optional parameter that allows you to specify additional options for configuring the
@@ -84,7 +78,9 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * other configuration settings specific
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -133,12 +129,15 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of AVLTreeNode.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param {K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): keyNodeOrEntry is AVLTreeNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeNode;
   }
 
@@ -148,13 +147,17 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the add method of a class and inserts a key-value pair into a data
    * structure, then balances the path.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept values of type `R`, `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `
    * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
    * the key or node being added to the data structure.
    * @returns The method is returning a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (keyNodeOrEntry === null) return false;
     const inserted = super.add(keyNodeOrEntry, value);
     if (inserted) this._balancePath(keyNodeOrEntry);
@@ -167,14 +170,16 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the delete method in a TypeScript class, performs deletion, and then
    * balances the tree if necessary.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override delete` method can be one of the following types:
    * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
    * method from the superclass (presumably a parent class) with the provided `predicate`, which could
    * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
    * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
    */
-  override delete(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
+  override delete(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
     const deletedResults = super.delete(keyNodeOrEntry);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
@@ -487,10 +492,11 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
    * to restore balance in an AVL tree after inserting a node.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
-   * `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } node - The `node` parameter can be of type `R` or
+   * `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    */
-  protected _balancePath(node: BTNRep<K, V, AVLTreeNode<K, V>>): void {
+  protected _balancePath(node: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): void {
     node = this.ensureNode(node);
     const path = this.getPathToRoot(node, node => node, false); // first O(log n) + O(log n)
     for (let i = 0; i < path.length; i++) {
diff --git a/src/data-structures/binary-tree/binary-tree.ts b/src/data-structures/binary-tree/binary-tree.ts
index de27a58..d70a110 100644
--- a/src/data-structures/binary-tree/binary-tree.ts
+++ b/src/data-structures/binary-tree/binary-tree.ts
@@ -11,7 +11,6 @@ import type {
   BinaryTreeOptions,
   BinaryTreePrintOptions,
   BTNEntry,
-  BTNRep,
   DFSOrderPattern,
   DFSStackItem,
   EntryCallback,
@@ -36,6 +35,10 @@ import { DFSOperation, Range } from '../../common';
  * @template BinaryTreeNode<K, V> - The type of the family relationship in the binary tree.
  */
 export class BinaryTreeNode<K = any, V = any> {
+  key: K;
+  value?: V;
+  parent?: BinaryTreeNode<K, V> = undefined;
+
   /**
    * The constructor function initializes an object with a key and an optional value in TypeScript.
    * @param {K} key - The `key` parameter in the constructor function is used to store the key value
@@ -49,32 +52,26 @@ export class BinaryTreeNode<K = any, V = any> {
     this.value = value;
   }
 
-  key: K;
+  _left?: BinaryTreeNode<K, V> | null | undefined = undefined;
 
-  value?: V;
-
-  parent?: BinaryTreeNode<K, V> = undefined;
-
-  _left?: OptNodeOrNull<BinaryTreeNode<K, V>> = undefined;
-
-  get left(): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  get left(): BinaryTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  set left(v: OptNodeOrNull<BinaryTreeNode<K, V>>) {
+  set left(v: BinaryTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this as unknown as BinaryTreeNode<K, V>;
     }
     this._left = v;
   }
 
-  _right?: OptNodeOrNull<BinaryTreeNode<K, V>> = undefined;
+  _right?: BinaryTreeNode<K, V> | null | undefined = undefined;
 
-  get right(): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  get right(): BinaryTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  set right(v: OptNodeOrNull<BinaryTreeNode<K, V>>) {
+  set right(v: BinaryTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -137,17 +134,21 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
   extends IterableEntryBase<K, V | undefined>
   implements IBinaryTree<K, V, R, MK, MV, MR>
 {
+  iterationType: IterationType = 'ITERATIVE';
+
   /**
    * This TypeScript constructor function initializes a binary tree with optional options and adds
    * elements based on the provided input.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either objects of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+   * iterable that can contain either objects of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
    * is used to initialize the binary tree with keys, nodes, entries, or raw data.
    * @param [options] - The `options` parameter in the constructor is an optional object that can
    * contain the following properties:
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, BinaryTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: BinaryTreeOptions<K, V, R>
   ) {
     super();
@@ -163,8 +164,6 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
 
-  iterationType: IterationType = 'ITERATIVE';
-
   protected _isMapMode = true;
 
   get isMapMode() {
@@ -183,9 +182,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return this._store;
   }
 
-  protected _root?: OptNodeOrNull<BinaryTreeNode<K, V>>;
+  protected _root?: BinaryTreeNode<K, V> | null | undefined;
 
-  get root(): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  get root(): BinaryTreeNode<K, V> | null | undefined {
     return this._root;
   }
 
@@ -249,8 +248,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `ensureNode` in TypeScript checks if a given input is a node, entry, key, or raw
    * value and returns the corresponding node or null.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `ensureNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+   * parameter in the `ensureNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It
    * is used to determine whether the input is a key, node, entry, or raw data. The
    * @param {IterationType} iterationType - The `iterationType` parameter in the `ensureNode` function
    * is used to specify the type of iteration to be performed. It has a default value of
@@ -259,9 +258,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * conditions specified in the code snippet.
    */
   ensureNode(
-    keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType: IterationType = this.iterationType
-  ): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  ): BinaryTreeNode<K, V> | null | undefined {
     if (keyNodeOrEntry === null) return null;
     if (keyNodeOrEntry === undefined) return;
     if (keyNodeOrEntry === this._NIL) return;
@@ -283,7 +282,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function isNode checks if the input is an instance of BinaryTreeNode.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
    * `keyNodeOrEntry` can be either a key, a node, an entry, or raw data. The function is
    * checking if the input is an instance of a `BinaryTreeNode` and returning a boolean value
    * accordingly.
@@ -292,7 +291,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * it is not an instance of `BinaryTreeNode`, the function returns `false`, indicating that the input
    * is not a node.
    */
-  isNode(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): keyNodeOrEntry is BinaryTreeNode<K, V> {
+  isNode(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is BinaryTreeNode<K, V> {
     return keyNodeOrEntry instanceof BinaryTreeNode;
   }
 
@@ -301,12 +302,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | R} keyNodeEntryOrRaw - BTNRep<K, V, BinaryTreeNode<K, V>>
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | R} keyNodeEntryOrRaw - K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
    * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
    * checking if it is an object. If the parameter is an object, the function will return `true`,
    * indicating that it is of type `R`.
    */
-  isRaw(keyNodeEntryOrRaw: BTNRep<K, V, BinaryTreeNode<K, V>> | R): keyNodeEntryOrRaw is R {
+  isRaw(
+    keyNodeEntryOrRaw: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+  ): keyNodeEntryOrRaw is R {
     return this._toEntryFn !== undefined && typeof keyNodeEntryOrRaw === 'object';
   }
 
@@ -315,15 +318,17 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function `isRealNode` checks if a given input is a valid node in a binary tree.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `isRealNode` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+   * parameter in the `isRealNode` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
    * The function checks if the input parameter is a `BinaryTreeNode<K, V>` type by verifying if it is not equal
    * @returns The function `isRealNode` is checking if the input `keyNodeOrEntry` is a valid
    * node by comparing it to `this._NIL`, `null`, and `undefined`. If the input is not one of these
    * values, it then calls the `isNode` method to further determine if the input is a node. The
    * function will return a boolean value indicating whether the
    */
-  isRealNode(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): keyNodeOrEntry is BinaryTreeNode<K, V> {
+  isRealNode(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is BinaryTreeNode<K, V> {
     if (keyNodeOrEntry === this._NIL || keyNodeOrEntry === null || keyNodeOrEntry === undefined) return false;
     return this.isNode(keyNodeOrEntry);
   }
@@ -333,14 +338,16 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function checks if a given input is a valid node or null.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
    * `keyNodeOrEntry` in the `isRealNodeOrNull` function can be of type `BTNRep<K,
    * V, BinaryTreeNode<K, V>>` or `R`. It is a union type that can either be a key, a node, an entry, or
    * @returns The function `isRealNodeOrNull` is returning a boolean value. It checks if the input
    * `keyNodeOrEntry` is either `null` or a real node, and returns `true` if it is a node or
    * `null`, and `false` otherwise.
    */
-  isRealNodeOrNull(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): keyNodeOrEntry is BinaryTreeNode<K, V> | null {
+  isRealNodeOrNull(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is BinaryTreeNode<K, V> | null {
     return keyNodeOrEntry === null || this.isRealNode(keyNodeOrEntry);
   }
 
@@ -349,12 +356,12 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function isNIL checks if a given key, node, entry, or raw value is equal to the _NIL value.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - BTNRep<K, V,
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - BTNRep<K, V,
    * BinaryTreeNode<K, V>>
    * @returns The function is checking if the `keyNodeOrEntry` parameter is equal to the `_NIL`
    * property of the current object and returning a boolean value based on that comparison.
    */
-  isNIL(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): boolean {
+  isNIL(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean {
     return keyNodeOrEntry === this._NIL;
   }
 
@@ -363,9 +370,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(1)
    *
    * The function `isRange` checks if the input parameter is an instance of the `Range` class.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>> | Range<K>} keyNodeEntryOrPredicate
    * - The `keyNodeEntryOrPredicate` parameter in the `isRange` function can be
-   * of type `BTNRep<K, V, BinaryTreeNode<K, V>>`, `NodePredicate<BinaryTreeNode<K, V>>`, or
+   * of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `NodePredicate<BinaryTreeNode<K, V>>`, or
    * `Range<K>`. The function checks if the `keyNodeEntry
    * @returns The `isRange` function is checking if the `keyNodeEntryOrPredicate` parameter is an
    * instance of the `Range` class. If it is an instance of `Range`, the function will return `true`,
@@ -373,7 +380,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * will return `false`.
    */
   isRange(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>> | Range<K>
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V>>
+      | Range<K>
   ): keyNodeEntryOrPredicate is Range<K> {
     return keyNodeEntryOrPredicate instanceof Range;
   }
@@ -384,14 +398,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
    * tree.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. It represents a
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It represents a
    * key, node, entry, or raw data in a binary tree structure. The function `isLeaf` checks whether the
    * provided
    * @returns The function `isLeaf` returns a boolean value indicating whether the input
    * `keyNodeOrEntry` is a leaf node in a binary tree.
    */
-  isLeaf(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): boolean {
+  isLeaf(keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): boolean {
     keyNodeOrEntry = this.ensureNode(keyNodeOrEntry);
     if (keyNodeOrEntry === undefined) return false;
     if (keyNodeOrEntry === null) return true;
@@ -404,14 +418,16 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `isEntry` checks if the input is a BTNEntry object by verifying if it is an array
    * with a length of 2.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `isEntry` function can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or type `R`.
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `keyNodeOrEntry`
+   * parameter in the `isEntry` function can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or type `R`.
    * The function checks if the provided `keyNodeOrEntry` is of type `BTN
    * @returns The `isEntry` function is checking if the `keyNodeOrEntry` parameter is an array
    * with a length of 2. If it is, then it returns `true`, indicating that the parameter is of type
    * `BTNEntry<K, V>`. If the condition is not met, it returns `false`.
    */
-  isEntry(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): keyNodeOrEntry is BTNEntry<K, V> {
+  isEntry(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is BTNEntry<K, V> {
     return Array.isArray(keyNodeOrEntry) && keyNodeOrEntry.length === 2;
   }
 
@@ -437,7 +453,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The `add` function in TypeScript adds a new node to a binary tree while handling duplicate keys
    * and finding the correct insertion position.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `add` method you provided
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `add` method you provided
    * seems to be for adding a new node to a binary tree structure. The `keyNodeOrEntry`
    * parameter in the method can accept different types of values:
    * @param {V} [value] - The `value` parameter in the `add` method represents the value associated
@@ -448,7 +464,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * node was successful, and `false` if the insertion position could not be found or if a duplicate
    * key was found and the node was replaced instead of inserted.
    */
-  add(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V): boolean {
+  add(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
@@ -515,7 +534,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * each insertion was successful.
    * @param keysNodesEntriesOrRaws - `keysNodesEntriesOrRaws` is an iterable that can contain a
    * mix of keys, nodes, entries, or raw values. Each element in this iterable can be of type
-   * `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`.
+   * `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`.
    * @param [values] - The `values` parameter in the `addMany` function is an optional parameter that
    * accepts an iterable of values. These values correspond to the keys or nodes being added in the
    * `keysNodesEntriesOrRaws` parameter. If provided, the function will iterate over the values and
@@ -525,7 +544,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * corresponds to the success of adding the corresponding key or value in the input iterable.
    */
   addMany(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, BinaryTreeNode<K, V>> | R>,
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    >,
     values?: Iterable<V | undefined>
   ): boolean[] {
     // TODO not sure addMany not be run multi times
@@ -571,13 +592,15 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * The `refill` function clears the existing data structure and then adds new key-value pairs based
    * on the provided input.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the `refill`
-   * method can accept an iterable containing a mix of `BTNRep<K, V, BinaryTreeNode<K, V>>` objects or `R`
+   * method can accept an iterable containing a mix of `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` objects or `R`
    * objects.
    * @param [values] - The `values` parameter in the `refill` method is an optional parameter that
    * accepts an iterable of values of type `V` or `undefined`.
    */
   refill(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, BinaryTreeNode<K, V>> | R>,
+    keysNodesEntriesOrRaws: Iterable<
+      K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    >,
     values?: Iterable<V | undefined>
   ): void {
     this.clear();
@@ -590,7 +613,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `delete` in TypeScript implements the deletion of a node in a binary tree and returns
    * the deleted node along with information for tree balancing.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry
    * - The `delete` method you provided is used to delete a node from a binary tree based on the key,
    * node, entry or raw data. The method returns an array of
    * `BinaryTreeDeleteResult` objects containing information about the deleted node and whether
@@ -599,7 +622,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * the array contains information about the node that was deleted (`deleted`) and the node that may
    * need to be balanced (`needBalanced`).
    */
-  delete(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
+  delete(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] {
     const deletedResult: BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[] = [];
     if (!this._root) return deletedResult;
 
@@ -650,15 +675,15 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
    * structure based on a given predicate or key, with options to return multiple results or just one.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
    * `keyNodeEntryOrPredicate` parameter in the `search` function can accept three types of values:
    * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
    * determines whether the search should stop after finding the first matching node. If `onlyOne` is
    * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
    * @param {C} callback - The `callback` parameter in the `search` function is a callback function
    * that will be called on each node that matches the search criteria. It is of type `C`, which
-   * extends `NodeCallback<BinaryTreeNode<K, V>>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `search` function is
+   * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `search` function is
    * used to specify the node from which the search operation should begin. It represents the starting
    * point in the binary tree where the search will be performed. If no specific `startNode` is
    * provided, the search operation will start from the root
@@ -668,11 +693,17 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * @returns The `search` function returns an array of values that match the provided criteria based
    * on the search algorithm implemented within the function.
    */
-  search<C extends NodeCallback<BinaryTreeNode<K, V>>>(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>,
+  search<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
     onlyOne = false,
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     if (keyNodeEntryOrPredicate === undefined) return [];
@@ -713,18 +744,31 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return ans;
   }
 
+  getNodes(
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V>>,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): BinaryTreeNode<K, V>[];
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(k + log n)
    *
    * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
    * or predicate, with options for recursive or iterative traversal.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
    * - The `getNodes` function you provided takes several parameters:
    * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
    * determines whether to return only the first node that matches the criteria specified by the
    * `keyNodeEntryOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getNodes` function is used to specify the starting point for traversing the binary tree. It
    * represents the root node of the binary tree or the node from which the traversal should begin. If
    * not provided, the default value is set to `this._root
@@ -735,11 +779,17 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * based on the input parameters and the iteration type specified.
    */
   getNodes(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>,
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
     onlyOne = false,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
-  ): BinaryTreeNode<K, V>[] {
+  ): (BinaryTreeNode<K, V> | null)[] {
     return this.search(keyNodeEntryOrPredicate, onlyOne, node => node, startNode, iterationType);
   }
 
@@ -749,10 +799,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The `getNode` function retrieves a node based on the provided key, node, entry, raw data, or
    * predicate.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
    * - The `keyNodeEntryOrPredicate` parameter in the `getNode` function can accept a key,
    * node, entry, raw data, or a predicate function.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getNode` function is used to specify the starting point for searching for a node in a binary
    * tree. If no specific starting point is provided, the default value is set to `this._root`, which
    * is typically the root node of the binary tree.
@@ -764,10 +814,16 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * or `null` if no matching node is found.
    */
   getNode(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
-  ): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  ): BinaryTreeNode<K, V> | null | undefined {
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType)[0];
   }
 
@@ -777,10 +833,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * This function overrides the `get` method to retrieve the value associated with a specified key,
    * node, entry, raw data, or predicate in a data structure.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
    * - The `keyNodeEntryOrPredicate` parameter in the `get` method can accept one of the
    * following types:
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `get`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `get`
    * method is used to specify the starting point for searching for a key or node in the binary tree.
    * If no specific starting point is provided, the default starting point is the root of the binary
    * tree (`this._root`).
@@ -794,8 +850,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * `undefined`.
    */
   override get(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>>,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    keyNodeEntryOrPredicate: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
     if (this._isMapMode) {
@@ -806,16 +862,28 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
 
+  override has(
+    keyNodeEntryOrPredicate?:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V>>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType
+  ): boolean;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(log n)
    *
    * The `has` function in TypeScript checks if a specified key, node, entry, raw data, or predicate
    * exists in the data structure.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate
    * - The `keyNodeEntryOrPredicate` parameter in the `override has` method can accept one of
    * the following types:
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `override` method is used to specify the starting point for the search operation within the data
    * structure. It defaults to `this._root` if not provided explicitly.
    * @param {IterationType} iterationType - The `iterationType` parameter in the `override has` method
@@ -828,8 +896,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Otherwise, it returns `false`.
    */
   override has(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): boolean {
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType).length > 0;
@@ -865,7 +939,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function checks if a binary tree is perfectly balanced by comparing its minimum height with
    * its height.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
    * point for checking if the binary tree is perfectly balanced. It represents the root node of the
    * binary tree or a specific node from which the balance check should begin.
    * @returns The method `isPerfectlyBalanced` is returning a boolean value, which indicates whether
@@ -874,7 +948,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * height plus 1 is greater than or equal to the height of the tree, then it is considered perfectly
    * balanced and
    */
-  isPerfectlyBalanced(startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root): boolean {
+  isPerfectlyBalanced(
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root
+  ): boolean {
     return this.getMinHeight(startNode) + 1 >= this.getHeight(startNode);
   }
 
@@ -884,7 +960,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `isBST` in TypeScript checks if a binary search tree is valid using either recursive
    * or iterative methods.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `isBST`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `isBST`
    * function represents the starting point for checking whether a binary search tree (BST) is valid.
    * It can be a node in the BST or a reference to the root of the BST. If no specific node is
    * provided, the function will default to
@@ -897,7 +973,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * less than the node's key, and all nodes in its right subtree have keys greater than the node's
    */
   isBST(
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): boolean {
     // TODO there is a bug
@@ -905,7 +981,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     if (!startNode) return true;
 
     if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: OptNodeOrNull<BinaryTreeNode<K, V>>, min: number, max: number): boolean => {
+      const dfs = (cur: BinaryTreeNode<K, V> | null | undefined, min: number, max: number): boolean => {
         if (!this.isRealNode(cur)) return true;
         const numKey = Number(cur.key);
         if (numKey <= min || numKey >= max) return false;
@@ -920,7 +996,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
         const stack = [];
         let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
         // @ts-ignore
-        let curr: OptNodeOrNull<BinaryTreeNode<K, V>> = startNode;
+        let curr: BinaryTreeNode<K, V> | null | undefined = startNode;
         while (this.isRealNode(curr) || stack.length > 0) {
           while (this.isRealNode(curr)) {
             stack.push(curr);
@@ -945,10 +1021,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Space Complexity: O(log n)
    *
    * The `getDepth` function calculates the depth between two nodes in a binary tree.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} dist - The `dist` parameter in the `getDepth`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } dist - The `dist` parameter in the `getDepth`
    * function represents the node or entry in a binary tree map, or a reference to a node in the tree.
    * It is the target node for which you want to calculate the depth from the `startNode` node.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getDepth` function represents the starting point from which you want to calculate the depth of a
    * given node or entry in a binary tree. If no specific starting point is provided, the default value
    * for `startNode` is set to the root of the binary
@@ -957,8 +1033,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * node, it returns the depth of the `dist` node from the root of the tree.
    */
   getDepth(
-    dist: BTNRep<K, V, BinaryTreeNode<K, V>>,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root
+    dist: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root
   ): number {
     let distEnsured = this.ensureNode(dist);
     const beginRootEnsured = this.ensureNode(startNode);
@@ -979,7 +1055,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The `getHeight` function calculates the maximum height of a binary tree using either a recursive
    * or iterative approach in TypeScript.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter is the starting
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
    * point from which the height of the binary tree will be calculated. It can be a node in the binary
    * tree or a reference to the root of the tree. If not provided, it defaults to the root of the
    * binary tree data structure.
@@ -991,14 +1067,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * recursive approach or an iterative approach depending on the `iterationType` parameter.
    */
   getHeight(
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): number {
     startNode = this.ensureNode(startNode);
     if (!this.isRealNode(startNode)) return -1;
 
     if (iterationType === 'RECURSIVE') {
-      const _getMaxHeight = (cur: OptNodeOrNull<BinaryTreeNode<K, V>>): number => {
+      const _getMaxHeight = (cur: BinaryTreeNode<K, V> | null | undefined): number => {
         if (!this.isRealNode(cur)) return -1;
         const leftHeight = _getMaxHeight(cur.left);
         const rightHeight = _getMaxHeight(cur.right);
@@ -1029,7 +1105,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The `getMinHeight` function calculates the minimum height of a binary tree using either a
    * recursive or iterative approach in TypeScript.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getMinHeight` function represents the starting node from which the minimum height of the binary
    * tree will be calculated. It is either a node in the binary tree or a reference to the root of the
    * tree. If not provided, the default value is the root
@@ -1042,14 +1118,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * a stack) based on the `iterationType` parameter.
    */
   getMinHeight(
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): number {
     startNode = this.ensureNode(startNode);
     if (!startNode) return -1;
 
     if (iterationType === 'RECURSIVE') {
-      const _getMinHeight = (cur: OptNodeOrNull<BinaryTreeNode<K, V>>): number => {
+      const _getMinHeight = (cur: BinaryTreeNode<K, V> | null | undefined): number => {
         if (!this.isRealNode(cur)) return 0;
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
         const leftMinHeight = _getMinHeight(cur.left);
@@ -1060,8 +1136,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       return _getMinHeight(startNode);
     } else {
       const stack: BinaryTreeNode<K, V>[] = [];
-      let node: OptNodeOrNull<BinaryTreeNode<K, V>> = startNode,
-        last: OptNodeOrNull<BinaryTreeNode<K, V>> = null;
+      let node: BinaryTreeNode<K, V> | null | undefined = startNode,
+        last: BinaryTreeNode<K, V> | null | undefined = null;
       const depths: Map<BinaryTreeNode<K, V>, number> = new Map();
 
       while (stack.length > 0 || node) {
@@ -1097,7 +1173,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * the path to the root. It is expected to be a function that takes a node as an argument and returns
    * a value based on that node. The return type of the callback function is determined by the generic
    * type `C
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} beginNode - The `beginNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } beginNode - The `beginNode` parameter in the
    * `getPathToRoot` function can be either a key, a node, an entry, or any other value of type `R`.
    * @param [isReverse=true] - The `isReverse` parameter in the `getPathToRoot` function determines
    * whether the resulting path from the given `beginNode` to the root should be in reverse order or
@@ -1108,7 +1184,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * parameter.
    */
   getPathToRoot<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
-    beginNode: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    beginNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     isReverse = false
   ): ReturnType<C>[] {
@@ -1135,7 +1211,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
    * node of a binary tree or with `undefined` if the tree is empty. It is provided with a default
    * value of `_DEFAULT_NODE_CALLBACK` if not specified.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
    * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
    * starting point is provided, the function will default
@@ -1149,7 +1225,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   getLeftMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C> {
     if (this.isNIL(startNode)) return callback(undefined);
@@ -1185,7 +1261,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * of finding the rightmost node in a binary tree. It is of type `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`,
    * which means it is a callback function that can accept either an optional binary tree node or null
    * as
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `getRightMost` function represents the starting point for finding the rightmost node in a binary
    * tree. It can be either a key, a node, or an entry in the binary tree structure. If no specific
    * starting point is provided, the function will default
@@ -1199,7 +1275,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   getRightMost<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C> {
     if (this.isNIL(startNode)) return callback(undefined);
@@ -1239,7 +1315,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   getPredecessor(node: BinaryTreeNode<K, V>): BinaryTreeNode<K, V> {
     if (this.isRealNode(node.left)) {
-      let predecessor: OptNodeOrNull<BinaryTreeNode<K, V>> = node.left;
+      let predecessor: BinaryTreeNode<K, V> | null | undefined = node.left;
       while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
         if (this.isRealNode(predecessor)) {
           predecessor = predecessor.right;
@@ -1264,7 +1340,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * have a right child, the function traverses up the parent nodes until it finds a node that is not
    * the right child of its parent, and returns that node
    */
-  getSuccessor(x?: K | BinaryTreeNode<K, V> | null): OptNodeOrNull<BinaryTreeNode<K, V>> {
+  getSuccessor(x?: K | BinaryTreeNode<K, V> | null): BinaryTreeNode<K, V> | null | undefined {
     x = this.ensureNode(x);
     if (!this.isRealNode(x)) return undefined;
 
@@ -1272,7 +1348,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       return this.getLeftMost(node => node, x.right);
     }
 
-    let y: OptNodeOrNull<BinaryTreeNode<K, V>> = x.parent;
+    let y: BinaryTreeNode<K, V> | null | undefined = x.parent;
     while (this.isRealNode(y) && x === y.right) {
       x = y;
       y = y.parent;
@@ -1283,14 +1359,16 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
   dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
     callback?: C,
     pattern?: DFSOrderPattern,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType
   ): ReturnType<C>[];
 
   dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback?: C,
     pattern?: DFSOrderPattern,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType,
     includeNull?: boolean
   ): ReturnType<C>[];
@@ -1299,50 +1377,53 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Time complexity: O(n)
    * Space complexity: O(n)
    *
-   * The function `dfs` performs a depth-first search traversal on a binary tree structure based on the
-   * specified parameters.
-   * @param {C} callback - The `callback` parameter is a generic type `C` that extends the
-   * `NodeCallback` interface with a type parameter of `OptNodeOrNull<BinaryTreeNode<K, V>>`. It has a default value of
-   * `this._DEFAULT_NODE_CALLBACK as C`.
-   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` method specifies the
-   * order in which the Depth-First Search (DFS) algorithm should traverse the nodes in the tree. The
-   * possible values for the `pattern` parameter are:
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `dfs`
-   * method is used to specify the starting point for the Depth-First Search traversal. It can be
-   * either a `BTNRep` object representing a key, node, or entry in the binary tree map,
-   * or it can be a
-   * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` method specifies
-   * the type of iteration to be performed during the depth-first search traversal. It is used to
-   * determine the order in which nodes are visited during the traversal.
-   * @param [includeNull=false] - The `includeNull` parameter in the `dfs` method is a boolean flag
-   * that determines whether null values should be included in the traversal or not. If `includeNull`
-   * is set to `true`, then null values will be included in the traversal process. If it is set to
-   * `false`,
-   * @returns The `dfs` method is returning an array of the return type specified by the generic type
-   * parameter `C`. The return type is determined by the callback function provided to the method.
+   * The function performs a depth-first search on a binary tree structure based on the specified
+   * parameters.
+   * @param {C} callback - The `callback` parameter is a function that will be called for each node
+   * visited during the depth-first search. It should accept a `BinaryTreeNode` as an argument and
+   * return an optional node or null. The default value for this parameter is `_DEFAULT_NODE_CALLBACK`.
+   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `dfs` function specifies
+   * the order in which the nodes are visited during a depth-first search traversal. The possible
+   * values for the `pattern` parameter are:
+   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `dfs` function is a boolean flag
+   * that determines whether the depth-first search should stop after finding the first matching node
+   * or continue searching for all matching nodes. If `onlyOne` is set to `true`, the search will stop
+   * after finding the first matching node
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+   * startNode - The `startNode` parameter in the `dfs` function can be one of the following types:
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `dfs` function
+   * specifies the type of iteration to be performed during the Depth-First Search traversal. It is
+   * used to determine the order in which nodes are visited during the traversal. The possible values
+   * for `iterationType` are typically defined as an enum or a
+   * @param [includeNull=false] - The `includeNull` parameter in the `dfs` function determines whether
+   * null nodes should be included in the depth-first search traversal. If `includeNull` is set to
+   * `true`, null nodes will be included in the traversal process. If it is set to `false`, null nodes
+   * will be skipped
+   * @returns The `dfs` method is returning an array of the return type of the callback function `C`.
    */
   dfs<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    onlyOne: boolean = false,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    return this._dfs(callback, pattern, startNode, iterationType, includeNull);
+    return this._dfs(callback, pattern, onlyOne, startNode, iterationType, includeNull);
   }
 
   bfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
     callback?: C,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[];
 
   bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback?: C,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[];
@@ -1356,7 +1437,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * @param {C} callback - The `callback` parameter in the `bfs` function is a function that will be
    * called on each node visited during the breadth-first search traversal. It is a generic type `C`
    * that extends the `NodeCallback` type, which takes a parameter of type `BinaryTreeNode<K, V>` or `null`.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `bfs`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `bfs`
    * function represents the starting point for the breadth-first search traversal in a binary tree. It
    * can be specified as a key, node, or entry in the binary tree structure. If not provided, the
    * default value is the root node of the binary
@@ -1372,14 +1453,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   bfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
 
-    const ans: ReturnType<NodeCallback<BinaryTreeNode<K, V>>>[] = [];
+    const ans: ReturnType<NodeCallback<BinaryTreeNode<K, V> | null>>[] = [];
 
     if (iterationType === 'RECURSIVE') {
       const queue: Queue<OptNodeOrNull<BinaryTreeNode<K, V>>> = new Queue<OptNodeOrNull<BinaryTreeNode<K, V>>>([
@@ -1434,7 +1515,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * structure based on a specified callback and iteration type.
    * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
    * in the binary tree. It is optional and defaults to a default callback function if not provided.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `leaves`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `leaves`
    * method is used to specify the starting point for finding and processing the leaves of a binary
    * tree. It can be provided as either a key, a node, or an entry in the binary tree structure. If not
    * explicitly provided, the default value
@@ -1446,11 +1527,11 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   leaves<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     startNode = this.ensureNode(startNode);
-    const leaves: ReturnType<NodeCallback<BinaryTreeNode<K, V>>>[] = [];
+    const leaves: ReturnType<NodeCallback<BinaryTreeNode<K, V> | null>>[] = [];
     if (!this.isRealNode(startNode)) return [];
 
     if (iterationType === 'RECURSIVE') {
@@ -1483,14 +1564,14 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
 
   listLevels<C extends NodeCallback<BinaryTreeNode<K, V>>>(
     callback?: C,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType,
     includeNull?: false
   ): ReturnType<C>[][];
 
   listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback?: C,
-    startNode?: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType?: IterationType,
     includeNull?: true
   ): ReturnType<C>[][];
@@ -1504,7 +1585,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * @param {C} callback - The `callback` parameter is a function that will be applied to each node in
    * the binary tree during the traversal. It is used to process each node and determine what
    * information to include in the output for each level of the tree.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `listLevels` function represents the starting point for traversing the binary tree. It can be
    * either a key, a node, or an entry in the binary tree. If not provided, the default value is the
    * root of the binary tree.
@@ -1521,7 +1602,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    */
   listLevels<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
@@ -1566,6 +1647,12 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return levelsNodes;
   }
 
+  morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): ReturnType<C>[];
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -1574,11 +1661,11 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * Morris Traversal algorithm with different order patterns.
    * @param {C} callback - The `callback` parameter in the `morris` function is a function that will be
    * called on each node in the binary tree during the traversal. It is of type `C`, which extends the
-   * `NodeCallback<BinaryTreeNode<K, V>>` type. The default value for `callback` is `this._DEFAULT
+   * `NodeCallback<BinaryTreeNode<K, V> | null>` type. The default value for `callback` is `this._DEFAULT
    * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `morris` function specifies
    * the type of Depth-First Search (DFS) order pattern to traverse the binary tree. The possible
    * values for the `pattern` parameter are:
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `morris`
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `morris`
    * function is the starting point for the Morris traversal algorithm. It represents the root node of
    * the binary tree or the node from which the traversal should begin. It can be provided as either a
    * key, a node, an entry, or a reference
@@ -1586,19 +1673,19 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * provided callback function to each node in the binary tree in the specified order pattern (IN,
    * PRE, or POST).
    */
-  morris<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+  morris<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root
   ): ReturnType<C>[] {
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    const ans: ReturnType<NodeCallback<BinaryTreeNode<K, V>>>[] = [];
+    const ans: ReturnType<NodeCallback<BinaryTreeNode<K, V> | null>>[] = [];
 
-    let cur: OptNodeOrNull<BinaryTreeNode<K, V>> = startNode;
-    const _reverseEdge = (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => {
-      let pre: OptNodeOrNull<BinaryTreeNode<K, V>> = null;
-      let next: OptNodeOrNull<BinaryTreeNode<K, V>> = null;
+    let cur: BinaryTreeNode<K, V> | null | undefined = startNode;
+    const _reverseEdge = (node: BinaryTreeNode<K, V> | null | undefined) => {
+      let pre: BinaryTreeNode<K, V> | null | undefined = null;
+      let next: BinaryTreeNode<K, V> | null | undefined = null;
       while (node) {
         next = node.right;
         node.right = pre;
@@ -1607,9 +1694,9 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       }
       return pre;
     };
-    const _printEdge = (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => {
-      const tail: OptNodeOrNull<BinaryTreeNode<K, V>> = _reverseEdge(node);
-      let cur: OptNodeOrNull<BinaryTreeNode<K, V>> = tail;
+    const _printEdge = (node: BinaryTreeNode<K, V> | null | undefined) => {
+      const tail: BinaryTreeNode<K, V> | null | undefined = _reverseEdge(node);
+      let cur: BinaryTreeNode<K, V> | null | undefined = tail;
       while (cur) {
         ans.push(callback(cur));
         cur = cur.right;
@@ -1689,22 +1776,6 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return cloned;
   }
 
-  protected _clone(cloned: BinaryTree<K, V, R, MK, MV, MR>) {
-    this.bfs(
-      node => {
-        if (node === null) cloned.add(null);
-        else {
-          if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
-          else cloned.add([node.key, node.value]);
-        }
-      },
-      this._root,
-      this.iterationType,
-      true
-    );
-    if (this._isMapMode) cloned._store = this._store;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1770,7 +1841,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `toVisual` in TypeScript overrides the visual representation of a binary tree with
    * customizable options for displaying undefined, null, and sentinel nodes.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `toVisual` method is used to specify the starting point for visualizing the binary tree structure.
    * It can be a node, key, entry, or the root of the tree. If no specific starting point is provided,
    * the default is set to the root
@@ -1783,7 +1854,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * binary tree with the specified options.
    */
   override toVisual(
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     options?: BinaryTreePrintOptions
   ): string {
     const opts = { isShowUndefined: false, isShowNull: true, isShowRedBlackNIL: false, ...options };
@@ -1795,7 +1866,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     if (opts.isShowNull) output += `N for null\n`;
     if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)\n`;
 
-    const display = (root: OptNodeOrNull<BinaryTreeNode<K, V>>): void => {
+    const display = (root: BinaryTreeNode<K, V> | null | undefined): void => {
       const [lines] = this._displayAux(root, opts);
       let paragraph = '';
       for (const line of lines) {
@@ -1818,37 +1889,56 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * printing options for the binary tree. It is an optional parameter that allows you to customize how
    * the binary tree is printed, such as choosing between different traversal orders or formatting
    * options.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the
    * `override print` method is used to specify the starting point for printing the binary tree. It can
    * be either a key, a node, an entry, or the root of the tree. If no specific starting point is
    * provided, the default value is set to
    */
-  override print(options?: BinaryTreePrintOptions, startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root) {
+  override print(
+    options?: BinaryTreePrintOptions,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root
+  ) {
     console.log(this.toVisual(startNode, options));
   }
 
+  protected _clone(cloned: BinaryTree<K, V, R, MK, MV, MR>) {
+    this.bfs(
+      node => {
+        if (node === null) cloned.add(null);
+        else {
+          if (this._isMapMode) cloned.add([node.key, this._store.get(node.key)]);
+          else cloned.add([node.key, node.value]);
+        }
+      },
+      this._root,
+      this.iterationType,
+      true
+    );
+    if (this._isMapMode) cloned._store = this._store;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
    * or returns null.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The
    * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeOrEntry`, which
-   * can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. This parameter represents either a key, a
+   * can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. This parameter represents either a key, a
    * node, an entry
    * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
    * an optional parameter of type `V`. It represents the value associated with the key in the node
    * being created. If a `value` is provided, it will be used when creating the node. If
    * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-   * (`OptNodeOrNull<BinaryTreeNode<K, V>>`) based on the input parameters provided. The function checks the type of the
+   * (`BinaryTreeNode<K, V> | null | undefined`) based on the input parameters provided. The function checks the type of the
    * input parameter (`keyNodeOrEntry`) and processes it accordingly to return a node or null
    * value.
    */
   protected _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>,
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
-  ): [OptNodeOrNull<BinaryTreeNode<K, V>>, V | undefined] {
+  ): [BinaryTreeNode<K, V> | null | undefined, V | undefined] {
     if (keyNodeOrEntry === undefined) return [undefined, undefined];
     if (keyNodeOrEntry === null) return [null, undefined];
 
@@ -1865,92 +1955,118 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     return [this.createNode(keyNodeOrEntry, value), value];
   }
 
+  protected _dfs<C extends NodeCallback<BinaryTreeNode<K, V>>>(
+    callback: C,
+    pattern?: DFSOrderPattern,
+    onlyOne?: boolean,
+    startNode?: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    iterationType?: IterationType,
+    includeNull?: boolean,
+    shouldVisitLeft?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean,
+    shouldVisitRight?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean,
+    shouldVisitRoot?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean,
+    shouldProcessRoot?: (node: BinaryTreeNode<K, V> | null | undefined) => boolean
+  ): ReturnType<C>[];
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
    *
-   * The `_dfs` function performs a depth-first search traversal on a binary tree structure based on
-   * the specified order pattern and callback function.
+   * The `_dfs` function performs a depth-first search traversal on a binary tree, with customizable
+   * options for traversal order and node processing.
    * @param {C} callback - The `callback` parameter in the `_dfs` method is a function that will be
-   * called on each node visited during the depth-first search traversal. It is of type `C`, which
-   * extends `NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>`. The default value for this parameter is `this._DEFAULT
+   * called on each node visited during the depth-first search traversal. It is a generic type `C` that
+   * extends `NodeCallback<BinaryTreeNode<K, V> | null>`. The default value for `callback`
    * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `_dfs` method specifies the
-   * order in which the nodes are visited during the Depth-First Search traversal. It can have one of
-   * the following values:
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} startNode - The `startNode` parameter in the `_dfs`
-   * method is used to specify the starting point for the depth-first search traversal in a binary
-   * tree. It can be provided as either a `BTNRep` object or a reference to the root node
-   * of the tree. If no specific
+   * order in which the nodes are visited during a depth-first search traversal. It can have one of the
+   * following values:
+   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `_dfs` method is a boolean flag
+   * that determines whether the traversal should stop after processing a single node. If `onlyOne` is
+   * set to `true`, the traversal will return as soon as a single node is processed. If it is set to
+   * `false
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined}
+   * startNode - The `startNode` parameter in the `_dfs` method is used to specify the starting node
+   * for the depth-first search traversal. It can be provided in different forms:
    * @param {IterationType} iterationType - The `iterationType` parameter in the `_dfs` method
-   * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
-   * binary tree. It can have two possible values:
-   * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method is a boolean flag
-   * that determines whether null nodes should be included in the depth-first search traversal. If
-   * `includeNull` is set to `true`, null nodes will be considered during the traversal process. If it
-   * is set to `false`,
-   * @param shouldVisitLeft - The `shouldVisitLeft` parameter is a function that takes a node as input
-   * and returns a boolean value. It is used to determine whether the left child of a node should be
-   * visited during the depth-first search traversal. By default, it checks if the node is truthy (not
-   * null or undefined
-   * @param shouldVisitRight - The `shouldVisitRight` parameter is a function that takes a node as an
-   * argument and returns a boolean value. It is used to determine whether the right child of a node
-   * should be visited during the depth-first search traversal. The default implementation checks if
-   * the node is truthy before visiting the right child
-   * @param shouldVisitRoot - The `shouldVisitRoot` parameter is a function that takes a node as an
-   * argument and returns a boolean value. It is used to determine whether the root node should be
-   * visited during the depth-first search traversal based on certain conditions. The default
-   * implementation checks if the node is a real node or null based
-   * @param shouldProcessRoot - The `shouldProcessRoot` parameter is a function that takes a node as an
-   * argument and returns a boolean value indicating whether the node should be processed during the
-   * depth-first search traversal. The default implementation checks if the node is a real node or null
-   * based on the `includeNull` flag. If `
-   * @returns The function `_dfs` returns an array of the return type of the callback function provided
-   * as input.
+   * specifies whether the traversal should be done recursively or iteratively. It can have two
+   * possible values:
+   * @param [includeNull=false] - The `includeNull` parameter in the `_dfs` method determines whether
+   * null nodes should be included in the traversal process. If `includeNull` is set to `true`, the
+   * method will consider null nodes as valid nodes to visit or process. If `includeNull` is set to
+   * `false`,
+   * @param shouldVisitLeft - The `shouldVisitLeft` parameter in the `_dfs` method is a function that
+   * determines whether the left child of a node should be visited during the Depth-First Search
+   * traversal. By default, it checks if the node is not null or undefined before visiting the left
+   * child. You can customize this behavior
+   * @param shouldVisitRight - The `shouldVisitRight` parameter in the `_dfs` method is a function that
+   * determines whether to visit the right child node of the current node during a depth-first search
+   * traversal. The default implementation of this function checks if the node is not null or undefined
+   * before deciding to visit it.
+   * @param shouldVisitRoot - The `shouldVisitRoot` parameter in the `_dfs` method is a function that
+   * determines whether a given node should be visited during the depth-first search traversal. The
+   * function takes a node as an argument and returns a boolean value indicating whether the node
+   * should be visited.
+   * @param shouldProcessRoot - The `shouldProcessRoot` parameter in the `_dfs` method is a function
+   * that determines whether the root node should be processed during the Depth-First Search traversal.
+   * It takes a node (BinaryTreeNode<K, V> | null | undefined) as input and returns a boolean value. If
+   * the function
+   * @returns The `_dfs` method returns an array of the return type of the provided callback function
+   * `C`.
    */
-  protected _dfs<C extends NodeCallback<OptNodeOrNull<BinaryTreeNode<K, V>>>>(
+  protected _dfs<C extends NodeCallback<BinaryTreeNode<K, V> | null>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
-    startNode: BTNRep<K, V, BinaryTreeNode<K, V>> = this._root,
+    onlyOne: boolean = false,
+    startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType,
     includeNull = false,
-    shouldVisitLeft: (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => boolean = node => !!node,
-    shouldVisitRight: (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => boolean = node => !!node,
-    shouldVisitRoot: (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => boolean = node => {
+    shouldVisitLeft: (node: BinaryTreeNode<K, V> | null | undefined) => boolean = node => !!node,
+    shouldVisitRight: (node: BinaryTreeNode<K, V> | null | undefined) => boolean = node => !!node,
+    shouldVisitRoot: (node: BinaryTreeNode<K, V> | null | undefined) => boolean = node => {
       if (includeNull) return this.isRealNodeOrNull(node);
       return this.isRealNode(node);
     },
-    shouldProcessRoot: (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => boolean = node => this.isRealNodeOrNull(node)
+    shouldProcessRoot: (node: BinaryTreeNode<K, V> | null | undefined) => boolean = node => this.isRealNodeOrNull(node)
   ): ReturnType<C>[] {
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
     const ans: ReturnType<C>[] = [];
 
     if (iterationType === 'RECURSIVE') {
-      const dfs = (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => {
+      const dfs = (node: BinaryTreeNode<K, V> | null) => {
         if (!shouldVisitRoot(node)) return;
 
         const visitLeft = () => {
-          if (shouldVisitLeft(node)) dfs(node?.left);
+          if (shouldVisitLeft(node) && node?.left !== undefined) dfs(node?.left);
         };
         const visitRight = () => {
-          if (shouldVisitRight(node)) dfs(node?.right);
+          if (shouldVisitRight(node) && node?.right !== undefined) dfs(node?.right);
         };
 
         switch (pattern) {
           case 'IN':
             visitLeft();
-            if (shouldProcessRoot(node)) ans.push(callback(node));
+            if (shouldProcessRoot(node)) {
+              ans.push(callback(node));
+              if (onlyOne) return;
+            }
             visitRight();
             break;
           case 'PRE':
-            if (shouldProcessRoot(node)) ans.push(callback(node));
+            if (shouldProcessRoot(node)) {
+              ans.push(callback(node));
+              if (onlyOne) return;
+            }
             visitLeft();
             visitRight();
             break;
           case 'POST':
             visitLeft();
             visitRight();
-            if (shouldProcessRoot(node)) ans.push(callback(node));
+            if (shouldProcessRoot(node)) {
+              ans.push(callback(node));
+              if (onlyOne) return;
+            }
             break;
         }
       };
@@ -1974,7 +2090,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
         if (cur === undefined) continue;
         if (!shouldVisitRoot(cur.node)) continue;
         if (cur.opt === DFSOperation.PROCESS) {
-          if (shouldProcessRoot(cur.node)) ans.push(callback(cur.node));
+          if (shouldProcessRoot(cur.node) && cur.node !== undefined) {
+            ans.push(callback(cur.node));
+            if (onlyOne) return ans;
+          }
         } else {
           switch (pattern) {
             case 'IN':
@@ -2019,8 +2138,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     if (!node) return;
 
     if (this.iterationType === 'ITERATIVE') {
-      const stack: OptNodeOrNull<BinaryTreeNode<K, V>>[] = [];
-      let current: OptNodeOrNull<BinaryTreeNode<K, V>> = node;
+      const stack: (BinaryTreeNode<K, V> | null | undefined)[] = [];
+      let current: BinaryTreeNode<K, V> | null | undefined = node;
 
       while (current || stack.length > 0) {
         while (this.isRealNode(current)) {
@@ -2063,7 +2182,10 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    * information about how to display a node in a binary tree. The `NodeDisplayLayout` consists of four
    * elements:
    */
-  protected _displayAux(node: OptNodeOrNull<BinaryTreeNode<K, V>>, options: BinaryTreePrintOptions): NodeDisplayLayout {
+  protected _displayAux(
+    node: BinaryTreeNode<K, V> | null | undefined,
+    options: BinaryTreePrintOptions
+  ): NodeDisplayLayout {
     const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
     const emptyDisplayLayout = <NodeDisplayLayout>[['─'], 1, 0, 0];
 
@@ -2131,26 +2253,26 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     }
   }
 
-  protected _DEFAULT_NODE_CALLBACK = (node: OptNodeOrNull<BinaryTreeNode<K, V>>) => (node ? node.key : undefined);
+  protected _DEFAULT_NODE_CALLBACK = (node: BinaryTreeNode<K, V> | null | undefined) => (node ? node.key : undefined);
 
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The _swapProperties function swaps key and value properties between two nodes in a binary tree.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} srcNode - The `srcNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } srcNode - The `srcNode` parameter in the
    * `_swapProperties` method can be either a BTNRep object containing key and value
    * properties, or it can be of type R.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} destNode - The `destNode` parameter in the
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } destNode - The `destNode` parameter in the
    * `_swapProperties` method represents the node or entry where the properties will be swapped with
-   * the `srcNode`. It can be of type `BTNRep<K, V, BinaryTreeNode<K, V>>` or `R`. The method ensures that
+   * the `srcNode`. It can be of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. The method ensures that
    * both `srcNode
    * @returns The `_swapProperties` method returns either the `destNode` with its key and value swapped
    * with the `srcNode`, or `undefined` if either `srcNode` or `destNode` is falsy.
    */
   protected _swapProperties(
-    srcNode: BTNRep<K, V, BinaryTreeNode<K, V>>,
-    destNode: BTNRep<K, V, BinaryTreeNode<K, V>>
+    srcNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    destNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
   ): BinaryTreeNode<K, V> | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
@@ -2210,45 +2332,67 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function _setRoot sets the root node of a data structure while updating the parent reference
    * of the previous root node.
-   * @param v - The parameter `v` in the `_setRoot` method is of type `OptNodeOrNull<BinaryTreeNode<K, V>>`, which means
+   * @param v - The parameter `v` in the `_setRoot` method is of type `BinaryTreeNode<K, V> | null | undefined`, which means
    * it can either be an optional `BinaryTreeNode<K, V>` type or `null`.
    */
-  protected _setRoot(v: OptNodeOrNull<BinaryTreeNode<K, V>>) {
+  protected _setRoot(v: BinaryTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = undefined;
     }
     this._root = v;
   }
 
+  protected _ensurePredicate(
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V>>
+  ): NodePredicate<BinaryTreeNode<K, V>>;
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The function `_ensurePredicate` in TypeScript ensures that the input is converted into a valid
    * predicate function for a binary tree node.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BinaryTreeNode<K, V>>} keyNodeEntryOrPredicate - The
    * `_ensurePredicate` method in the provided code snippet is responsible for ensuring that the input
    * parameter `keyNodeEntryOrPredicate` is transformed into a valid predicate function that can be
    * used for filtering nodes in a binary tree.
    * @returns A NodePredicate<BinaryTreeNode<K, V>> function is being returned.
    */
   protected _ensurePredicate(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>
-  ): NodePredicate<BinaryTreeNode<K, V>> {
+    keyNodeEntryOrPredicate:
+      | K
+      | BinaryTreeNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BinaryTreeNode<K, V> | null>
+  ): NodePredicate<BinaryTreeNode<K, V> | null> {
     if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === undefined)
-      return (node: BinaryTreeNode<K, V>) => (node ? false : false);
+      return (node: BinaryTreeNode<K, V> | null | undefined) => (node ? false : false);
 
     if (this._isPredicate(keyNodeEntryOrPredicate)) return keyNodeEntryOrPredicate;
 
     if (this.isRealNode(keyNodeEntryOrPredicate))
-      return (node: BinaryTreeNode<K, V>) => node === keyNodeEntryOrPredicate;
+      return (node: BinaryTreeNode<K, V> | null) => node === keyNodeEntryOrPredicate;
 
     if (this.isEntry(keyNodeEntryOrPredicate)) {
       const [key] = keyNodeEntryOrPredicate;
-      return (node: BinaryTreeNode<K, V>) => node.key === key;
+      return (node: BinaryTreeNode<K, V> | null) => {
+        if (!node) return false;
+        return node.key === key;
+      };
     }
 
-    return (node: BinaryTreeNode<K, V>) => node.key === keyNodeEntryOrPredicate;
+    return (node: BinaryTreeNode<K, V> | null) => {
+      if (!node) return false;
+      return node.key === keyNodeEntryOrPredicate;
+    };
   }
 
   /**
@@ -2273,14 +2417,16 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
    *
    * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
    * entry, raw data, or null/undefined.
-   * @param {BTNRep<K, V, BinaryTreeNode<K, V>>} keyNodeOrEntry - The `_extractKey` method you provided is a
-   * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `BTNRep<K, V, BinaryTreeNode<K, V>>`,
+   * @param {K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The `_extractKey` method you provided is a
+   * TypeScript method that takes in a parameter `keyNodeOrEntry` of type `K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `,
    * where `BTNRep` is a generic type with keys `K`, `V`, and `BinaryTreeNode<K, V>`, and `
    * @returns The `_extractKey` method returns the key value extracted from the `keyNodeOrEntry`
    * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
    * the conditions checked in the method.
    */
-  protected _extractKey(keyNodeOrEntry: BTNRep<K, V, BinaryTreeNode<K, V>>): K | null | undefined {
+  protected _extractKey(
+    keyNodeOrEntry: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): K | null | undefined {
     if (keyNodeOrEntry === null) return null;
     if (keyNodeOrEntry === undefined) return;
     if (keyNodeOrEntry === this._NIL) return;
diff --git a/src/data-structures/binary-tree/bst.ts b/src/data-structures/binary-tree/bst.ts
index 43fd0ec..b896be2 100644
--- a/src/data-structures/binary-tree/bst.ts
+++ b/src/data-structures/binary-tree/bst.ts
@@ -17,8 +17,7 @@ import type {
   IterationType,
   NodeCallback,
   NodePredicate,
-  OptNode,
-  OptNodeOrNull
+  OptNode
 } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -27,6 +26,8 @@ import { isComparable } from '../../utils';
 import { Range } from '../../common';
 
 export class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
+  override parent?: BSTNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor function initializes an instance with a key and an optional value.
    * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
@@ -40,28 +41,26 @@ export class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
     super(key, value);
   }
 
-  override parent?: BSTNode<K, V> = undefined;
+  override _left?: BSTNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<BSTNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<BSTNode<K, V>> {
+  override get left(): BSTNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<BSTNode<K, V>>) {
+  override set left(v: BSTNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<BSTNode<K, V>> = undefined;
+  override _right?: BSTNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<BSTNode<K, V>> {
+  override get right(): BSTNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<BSTNode<K, V>>) {
+  override set right(v: BSTNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -142,12 +141,17 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * This TypeScript constructor initializes a binary search tree with optional options and adds
    * elements if provided.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain elements of type `BTNRep<K, V, BSTNode<K, V>>` or `R`. It is used to
+   * iterable that can contain elements of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  ` or `R`. It is used to
    * initialize the binary search tree with keys, nodes, entries, or raw data.
    * @param [options] - The `options` parameter is an optional object that can contain the following
    * properties:
    */
-  constructor(keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, BSTNode<K, V>> | R> = [], options?: BSTOptions<K, V, R>) {
+  constructor(
+    keysNodesEntriesOrRaws: Iterable<
+      K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
+    options?: BSTOptions<K, V, R>
+  ) {
     super([], options);
 
     if (options) {
@@ -243,7 +247,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    *
    * The function ensures the existence of a node in a data structure and returns it, or undefined if
    * it doesn't exist.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
    * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
    * entry, or raw element that needs to be ensured in the tree.
    * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
@@ -253,7 +257,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * not be ensured.
    */
   override ensureNode(
-    keyNodeOrEntry: BTNRep<K, V, BSTNode<K, V>>,
+    keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     iterationType: IterationType = this.iterationType
   ): OptNode<BSTNode<K, V>> {
     return super.ensureNode(keyNodeOrEntry, iterationType) ?? undefined;
@@ -264,12 +268,14 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the BSTNode class.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `BSTNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, BSTNode<K, V>>): keyNodeOrEntry is BSTNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is BSTNode<K, V> {
     return keyNodeOrEntry instanceof BSTNode;
   }
 
@@ -293,13 +299,16 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * Space Complexity: O(log n)
    *
    * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept a value of type `R` or `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `.
    * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
    * key in the binary search tree. If provided, it will be stored in the node along with the key.
    * @returns a boolean value.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, BSTNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
@@ -383,7 +392,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
     }
 
     const realBTNExemplars: {
-      key: R | BTNRep<K, V, BSTNode<K, V>>;
+      key: R | K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined;
       value: V | undefined;
       orgIndex: number;
     }[] = [];
@@ -394,7 +403,11 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       i++;
     }
 
-    let sorted: { key: R | BTNRep<K, V, BSTNode<K, V>>; value: V | undefined; orgIndex: number }[] = [];
+    let sorted: {
+      key: R | K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined;
+      value: V | undefined;
+      orgIndex: number;
+    }[] = [];
 
     sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
       let keyA: K | undefined | null, keyB: K | undefined | null;
@@ -418,7 +431,13 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       return 0;
     });
 
-    const _dfs = (arr: { key: R | BTNRep<K, V, BSTNode<K, V>>; value: V | undefined; orgIndex: number }[]) => {
+    const _dfs = (
+      arr: {
+        key: R | K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined;
+        value: V | undefined;
+        orgIndex: number;
+      }[]
+    ) => {
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
@@ -473,7 +492,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    *
    * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
    * on specified criteria.
-   * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
    * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
    * following types:
    * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
@@ -481,9 +500,9 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
    * @param {C} callback - The `callback` parameter in the `override search` function is a function
    * that will be called on each node that matches the search criteria. It is of type `C`, which
-   * extends `NodeCallback<BSTNode<K, V>>`. The callback function should accept a node of type `BSTNode<K, V>` as its
+   * extends `NodeCallback<BSTNode<K, V> | null>`. The callback function should accept a node of type `BSTNode<K, V>` as its
    * argument and
-   * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `override search`
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `override search`
    * method represents the node from which the search operation will begin. It is the starting point
    * for searching within the tree data structure. The method ensures that the `startNode` is a valid
    * node before proceeding with the search operation. If the `
@@ -496,10 +515,17 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * collected in an array and returned as the output of the method.
    */
   override search<C extends NodeCallback<BSTNode<K, V>>>(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>> | Range<K>,
+    keyNodeEntryOrPredicate:
+      | K
+      | BSTNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BSTNode<K, V>>
+      | Range<K>,
     onlyOne = false,
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     if (keyNodeEntryOrPredicate === undefined) return [];
@@ -511,21 +537,32 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
     const isRange = this.isRange(keyNodeEntryOrPredicate);
     // Set predicate based on parameter type
     if (isRange) {
-      predicate = node => keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
+      predicate = node => {
+        if (!node) return false;
+        return keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
+      };
     } else {
       predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
     }
-    const isToLeftByRange = (cur: BSTNode<K, V>) => {
+    const shouldVisitLeft = (cur: BSTNode<K, V> | null | undefined) => {
+      if (!cur) return false;
+      if (!this.isRealNode(cur.left)) return false;
       if (isRange) {
         const range = keyNodeEntryOrPredicate;
         const leftS = this.isReverse ? range.high : range.low;
         const leftI = this.isReverse ? range.includeHigh : range.includeLow;
         return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
       }
-      return false;
+      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
+        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
+        return benchmarkKey !== null && benchmarkKey !== undefined && this._compare(cur.key, benchmarkKey) > 0;
+      }
+      return true;
     };
 
-    const isToRightByRange = (cur: BSTNode<K, V>) => {
+    const shouldVisitRight = (cur: BSTNode<K, V> | null | undefined) => {
+      if (!cur) return false;
+      if (!this.isRealNode(cur.right)) return false;
       if (isRange) {
         const range = keyNodeEntryOrPredicate;
         const rightS = this.isReverse ? range.low : range.high;
@@ -533,79 +570,27 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
 
         return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
       }
-      return false;
-    };
-    const ans: ReturnType<C>[] = [];
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: BSTNode<K, V>) => {
-        if (predicate(cur)) {
-          ans.push(callback(cur));
-          if (onlyOne) return;
-        }
-
-        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
-
-        if (isRange) {
-          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) dfs(cur.left);
-          if (this.isRealNode(cur.right) && isToRightByRange(cur)) dfs(cur.right);
-        } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-          const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-          if (
-            this.isRealNode(cur.left) &&
-            benchmarkKey !== null &&
-            benchmarkKey !== undefined &&
-            this._compare(cur.key, benchmarkKey) > 0
-          )
-            dfs(cur.left);
-          if (
-            this.isRealNode(cur.right) &&
-            benchmarkKey !== null &&
-            benchmarkKey !== undefined &&
-            this._compare(cur.key, benchmarkKey) < 0
-          )
-            dfs(cur.right);
-        } else {
-          if (this.isRealNode(cur.left)) dfs(cur.left);
-          if (this.isRealNode(cur.right)) dfs(cur.right);
-        }
-      };
-
-      dfs(startNode);
-    } else {
-      const stack = [startNode];
-      while (stack.length > 0) {
-        const cur = stack.pop()!;
-        if (predicate(cur)) {
-          ans.push(callback(cur));
-          if (onlyOne) return ans;
-        }
-        if (isRange) {
-          if (this.isRealNode(cur.left) && isToLeftByRange(cur)) stack.push(cur.left);
-          if (this.isRealNode(cur.right) && isToRightByRange(cur)) stack.push(cur.right);
-        } else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-          const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
-          if (
-            this.isRealNode(cur.right) &&
-            benchmarkKey !== null &&
-            benchmarkKey !== undefined &&
-            this._compare(cur.key, benchmarkKey) < 0
-          )
-            stack.push(cur.right);
-          if (
-            this.isRealNode(cur.left) &&
-            benchmarkKey !== null &&
-            benchmarkKey !== undefined &&
-            this._compare(cur.key, benchmarkKey) > 0
-          )
-            stack.push(cur.left);
-        } else {
-          if (this.isRealNode(cur.right)) stack.push(cur.right);
-          if (this.isRealNode(cur.left)) stack.push(cur.left);
-        }
+      if (!isRange && !this._isPredicate(keyNodeEntryOrPredicate)) {
+        const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
+        return benchmarkKey !== null && benchmarkKey !== undefined && this._compare(cur.key, benchmarkKey) < 0;
       }
-    }
-
-    return ans;
+      return true;
+    };
+    return super._dfs(
+      callback,
+      'IN',
+      onlyOne,
+      startNode,
+      iterationType,
+      false,
+      shouldVisitLeft,
+      shouldVisitRight,
+      () => true,
+      cur => {
+        if (cur) return predicate(cur);
+        return false;
+      }
+    );
   }
 
   /**
@@ -617,9 +602,9 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * either a `Range` object or an array of two elements representing the range boundaries.
    * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
    * function that is used to process each node that is found within the specified range during the
-   * search operation. It is of type `NodeCallback<BSTNode<K, V>>`, where `BSTNode<K, V>` is the type of nodes in the
+   * search operation. It is of type `NodeCallback<BSTNode<K, V> | null>`, where `BSTNode<K, V>` is the type of nodes in the
    * data structure.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `rangeSearch`
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter in the `rangeSearch`
    * function represents the node from which the search for nodes within the specified range will
    * begin. It is the starting point for the range search operation.
    * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
@@ -632,7 +617,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   rangeSearch<C extends NodeCallback<BSTNode<K, V>>>(
     range: Range<K> | [K, K],
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ) {
     const searchRange: Range<K> = range instanceof Range ? range : new Range(range[0], range[1]);
@@ -644,8 +629,8 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * Space Complexity: O(log n)
    *
    * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
-   * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
-   * parameter can be of type `BTNRep<K, V, BSTNode<K, V>>`, `R`, or `NodePredicate<BSTNode<K, V>>`.
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined   | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
+   * parameter can be of type `K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  `, `R`, or `NodePredicate<BSTNode<K, V>>`.
    * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
    * is used to specify the starting point for searching nodes in the binary search tree. If no
    * specific starting point is provided, the default value is set to `this._root`, which is the root
@@ -660,7 +645,13 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * returns the first node found or `undefined` if no node is found.
    */
   override getNode(
-    keyNodeEntryOrPredicate: BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>,
+    keyNodeEntryOrPredicate:
+      | K
+      | BSTNode<K, V>
+      | [K | null | undefined, V | undefined]
+      | null
+      | undefined
+      | NodePredicate<BSTNode<K, V>>,
     startNode: BSTNOptKeyOrNode<K, BSTNode<K, V>> = this._root,
     iterationType: IterationType = this.iterationType
   ): OptNode<BSTNode<K, V>> {
@@ -671,29 +662,36 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * Time complexity: O(n)
    * Space complexity: O(n)
    *
-   * The function overrides the depth-first search method and returns an array of the return types of
-   * the callback function.
+   * The function `dfs` in TypeScript overrides the base class method with default parameters and
+   * returns the result of the super class `dfs` method.
    * @param {C} callback - The `callback` parameter is a function that will be called for each node
-   * during the depth-first search traversal. It is an optional parameter and defaults to
-   * `this._DEFAULT_NODE_CALLBACK`. The type `C` represents the type of the callback function.
-   * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
-   * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
-   * take one of the following values:
-   * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
-   * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
-   * node entry. If not specified, the default value is the root of the tree.
-   * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
-   * type of iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
-   * following values:
-   * @returns The method is returning an array of the return type of the callback function.
+   * visited during the Depth-First Search traversal. It is a generic type `C` that extends the
+   * `NodeCallback` interface for `BSTNode<K, V>`. The default value for `callback` is `this._
+   * @param {DFSOrderPattern} [pattern=IN] - The `pattern` parameter in the `override dfs` method
+   * specifies the order in which the Depth-First Search (DFS) traversal should be performed on the
+   * Binary Search Tree (BST). The possible values for the `pattern` parameter are:
+   * @param {boolean} [onlyOne=false] - The `onlyOne` parameter in the `override dfs` method is a
+   * boolean flag that indicates whether you want to stop the depth-first search traversal after
+   * finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set
+   * to `true`, the traversal will stop after finding
+   * @param {K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} startNode -
+   * The `startNode` parameter in the `override dfs` method can be one of the following types:
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `override dfs` method
+   * specifies the type of iteration to be performed during the Depth-First Search (DFS) traversal of a
+   * Binary Search Tree (BST). It is used to determine the order in which nodes are visited during the
+   * traversal. The possible values for `
+   * @returns The `override` function is returning the result of calling the `dfs` method from the
+   * superclass, with the provided arguments `callback`, `pattern`, `onlyOne`, `startNode`, and
+   * `iterationType`. The return type is an array of the return type of the callback function `C`.
    */
   override dfs<C extends NodeCallback<BSTNode<K, V>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
-    startNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    onlyOne: boolean = false,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
-    return super.dfs(callback, pattern, startNode, iterationType);
+    return super.dfs(callback, pattern, onlyOne, startNode, iterationType);
   }
 
   /**
@@ -705,7 +703,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * @param {C} callback - The `callback` parameter is a function that will be called for each node
    * visited during the breadth-first search. It should take a single argument, which is the current
    * node being visited, and it can return a value of any type.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
    * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
    * object. If no value is provided, the default value is the root of the tree.
    * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -715,7 +713,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    */
   override bfs<C extends NodeCallback<BSTNode<K, V>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     return super.bfs(callback, startNode, iterationType, false);
@@ -728,9 +726,9 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * The function overrides the listLevels method from the superclass and returns an array of arrays
    * containing the results of the callback function applied to each level of the tree.
    * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-   * `NodeCallback<BSTNode<K, V>>`. It represents a callback function that will be called for each node in the
+   * `NodeCallback<BSTNode<K, V> | null>`. It represents a callback function that will be called for each node in the
    * tree during the iteration process.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } startNode - The `startNode` parameter is the starting
    * point for listing the levels of the binary tree. It can be either a root node of the tree, a
    * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
    * value is provided, the root of
@@ -741,7 +739,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    */
   override listLevels<C extends NodeCallback<BSTNode<K, V>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
-    startNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    startNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
     return super.listLevels(callback, startNode, iterationType, false);
@@ -759,7 +757,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
    * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
    * 0, or 1, where:
-   * @param {BTNRep<K, V, BSTNode<K, V>>} targetNode - The `targetNode` parameter is the node in
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } targetNode - The `targetNode` parameter is the node in
    * the binary tree that you want to start traversing from. It can be specified either by providing
    * the key of the node, the node itself, or an entry containing the key and value of the node. If no
    * `targetNode` is provided,
@@ -771,7 +769,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   lesserOrGreaterTraverse<C extends NodeCallback<BSTNode<K, V>>>(
     callback: C = this._DEFAULT_NODE_CALLBACK as C,
     lesserOrGreater: CP = -1,
-    targetNode: BTNRep<K, V, BSTNode<K, V>> = this._root,
+    targetNode: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     const targetNodeEnsured = this.ensureNode(targetNode);
@@ -831,8 +829,8 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        if (this._isMapMode) this.add(midNode.key);
-        else this.add([midNode.key, midNode.value]);
+        if (this._isMapMode && midNode !== null) this.add(midNode.key);
+        else if (midNode !== null) this.add([midNode.key, midNode.value]);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -848,8 +846,8 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            if (this._isMapMode) this.add(midNode.key);
-            else this.add([midNode.key, midNode.value]);
+            if (this._isMapMode && midNode !== null) this.add(midNode.key);
+            else if (midNode !== null) this.add([midNode.key, midNode.value]);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -877,7 +875,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
     let balanced = true;
 
     if (iterationType === 'RECURSIVE') {
-      const _height = (cur: OptNodeOrNull<BSTNode<K, V>>): number => {
+      const _height = (cur: BSTNode<K, V> | null | undefined): number => {
         if (!cur) return 0;
         const leftHeight = _height(cur.left),
           rightHeight = _height(cur.right);
@@ -966,15 +964,15 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
    * Space Complexity: O(1)
    *
    * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-   * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - A variable that can be of
-   * type R or BTNRep<K, V, BSTNode<K, V>>. It represents either a key, a node, an entry, or a raw
+   * @param {K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  } keyNodeOrEntry - A variable that can be of
+   * type R or K |  BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined  . It represents either a key, a node, an entry, or a raw
    * element.
    * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
    * value associated with a key in a key-value pair.
    * @returns either a BSTNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, BSTNode<K, V>>,
+    keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): [OptNode<BSTNode<K, V>>, V | undefined] {
     const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
diff --git a/src/data-structures/binary-tree/red-black-tree.ts b/src/data-structures/binary-tree/red-black-tree.ts
index ccd773e..8dcdf00 100644
--- a/src/data-structures/binary-tree/red-black-tree.ts
+++ b/src/data-structures/binary-tree/red-black-tree.ts
@@ -1,17 +1,10 @@
-import type {
-  BinaryTreeDeleteResult,
-  BTNRep,
-  CRUD,
-  EntryCallback,
-  OptNode,
-  OptNodeOrNull,
-  RBTNColor,
-  RedBlackTreeOptions
-} from '../../types';
+import type { BinaryTreeDeleteResult, CRUD, EntryCallback, OptNode, RBTNColor, RedBlackTreeOptions } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
 export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
+  override parent?: RedBlackTreeNode<K, V> = undefined;
+
   /**
    * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
    * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
@@ -27,28 +20,26 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
     this._color = color;
   }
 
-  override parent?: RedBlackTreeNode<K, V> = undefined;
+  override _left?: RedBlackTreeNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+  override get left(): RedBlackTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+  override set left(v: RedBlackTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
+  override _right?: RedBlackTreeNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+  override get right(): RedBlackTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+  override set right(v: RedBlackTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -117,7 +108,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
    * raw data.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+   * iterable that can contain either `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined` objects or `R` objects. It
    * is used to initialize the Red-Black Tree with keys, nodes, entries, or
    * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
    * V, R>`. It is an optional parameter that allows you to specify additional options for the
@@ -125,7 +116,9 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * any other parameters that are specific to
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, RedBlackTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: RedBlackTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -188,12 +181,14 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `RedBlackTreeNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>): keyNodeOrEntry is RedBlackTreeNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is RedBlackTreeNode<K, V> {
     return keyNodeOrEntry instanceof RedBlackTreeNode;
   }
 
@@ -215,8 +210,8 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function adds a new node to a binary search tree and returns true if the node was successfully
    * added.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept a value of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
    * the key in the data structure. It represents the value that you want to add or update in the data
    * structure.
@@ -224,7 +219,10 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * the method returns true. If the node already exists and its value is updated, the method also
    * returns true. If the node cannot be added or updated, the method returns false.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (!this.isRealNode(newNode)) return false;
 
@@ -254,7 +252,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function overrides the delete method in a binary tree data structure to remove a node based on
    * a given predicate and maintain the binary search tree properties.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override delete` method is used to specify the condition or key based on which a
    * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
    * function that determines which node(s) should be deleted.
@@ -263,7 +261,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * balancing is needed.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
   ): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[] {
     if (keyNodeOrEntry === null) return [];
 
diff --git a/src/data-structures/binary-tree/tree-counter.ts b/src/data-structures/binary-tree/tree-counter.ts
index 83b5d9d..0f8bec6 100644
--- a/src/data-structures/binary-tree/tree-counter.ts
+++ b/src/data-structures/binary-tree/tree-counter.ts
@@ -8,11 +8,9 @@
 import type {
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep,
   EntryCallback,
   IterationType,
   OptNode,
-  OptNodeOrNull,
   RBTNColor,
   TreeCounterOptions
 } from '../../types';
@@ -20,6 +18,8 @@ import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 
 export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
+  override parent?: TreeCounterNode<K, V> = undefined;
+
   /**
    * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
    * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -37,28 +37,26 @@ export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
     this.count = count;
   }
 
-  override parent?: TreeCounterNode<K, V> = undefined;
+  override _left?: TreeCounterNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<TreeCounterNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<TreeCounterNode<K, V>> {
+  override get left(): TreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<TreeCounterNode<K, V>>) {
+  override set left(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<TreeCounterNode<K, V>> = undefined;
+  override _right?: TreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<TreeCounterNode<K, V>> {
+  override get right(): TreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<TreeCounterNode<K, V>>) {
+  override set right(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -83,7 +81,9 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * `compareValues`, which are functions used to compare keys and values respectively.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, TreeCounterNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: TreeCounterOptions<K, V, R>
   ) {
     super([], options);
@@ -111,7 +111,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    */
   getComputedCount(): number {
     let sum = 0;
-    this.dfs(node => (sum += node.count));
+    this.dfs(node => (sum += node ? node.count : 0));
     return sum;
   }
 
@@ -152,12 +152,14 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
 
   /**
    * The function checks if the input is an instance of the TreeCounterNode class.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `TreeCounterNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>): keyNodeOrEntry is TreeCounterNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is TreeCounterNode<K, V> {
     return keyNodeOrEntry instanceof TreeCounterNode;
   }
 
@@ -167,7 +169,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function overrides the add method of a class and adds a new node to a data structure, updating
    * the count and returning a boolean indicating success.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
    * `keyNodeOrEntry` parameter can accept one of the following types:
    * @param {V} [value] - The `value` parameter represents the value associated with the key in the
    * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -177,7 +179,11 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The method is returning a boolean value. It returns true if the addition of the new node
    * was successful, and false otherwise.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count = 1): boolean {
+  override add(
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V,
+    count = 1
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
     const isSuccessAdded = super.add(newNode, newValue);
@@ -196,7 +202,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
    * structure, handling cases where nodes have children and maintaining balance in the tree.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
    * parameter in the `delete` method is used to specify the condition or key based on which a node
    * should be deleted from the binary tree. It can be a key, a node, or an entry.
    * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
@@ -206,7 +212,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     ignoreCount = false
   ): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[] {
     if (keyNodeOrEntry === null) return [];
@@ -340,8 +346,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
-        else this.add(midNode.key, midNode.value, midNode.count);
+        if (this._isMapMode && midNode !== null) this.add(midNode.key, undefined, midNode.count);
+        else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -357,8 +363,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
-            else this.add(midNode.key, midNode.value, midNode.count);
+            if (this._isMapMode && midNode !== null) this.add(midNode.key, undefined, midNode.count);
+            else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -377,7 +383,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    */
   override clone() {
     const cloned = this.createTree();
-    this.bfs(node => cloned.add(node.key, undefined, node.count));
+    this.bfs(node => cloned.add(node === null ? null : node.key, undefined, node === null ? 0 : node.count));
     if (this._isMapMode) cloned._store = this._store;
     return cloned;
   }
@@ -413,8 +419,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
   /**
    * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
    * node based on the input.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that represents the value
    * associated with the key in the node. It is used when creating a new node or updating the value of
    * an existing node.
@@ -423,7 +429,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns either a TreeCounterNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): [TreeCounterNode<K, V> | undefined, V | undefined] {
diff --git a/src/data-structures/binary-tree/tree-multi-map.ts b/src/data-structures/binary-tree/tree-multi-map.ts
index 215008b..57df1c6 100644
--- a/src/data-structures/binary-tree/tree-multi-map.ts
+++ b/src/data-structures/binary-tree/tree-multi-map.ts
@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNOptKeyOrNull, BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
+import type { BTNOptKeyOrNull, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+  override parent?: TreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -23,28 +25,26 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
     super(key, value);
   }
 
-  override parent?: TreeMultiMapNode<K, V> = undefined;
+  override _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get left(): TreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set left(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
+  override _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get right(): TreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set right(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -77,7 +77,9 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * additional options for configuring the TreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: TreeMultiMapOptions<K, V[], R>
   ) {
     super([], { ...options, isMapMode: true });
@@ -124,7 +126,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     return new TreeMultiMapNode<K, V>(key, []);
   }
 
-  override add(node: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+  override add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -134,7 +136,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
    * TreeMultiMapNode, handling different input types and scenarios.
-   * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
    * of values, and a `TreeMultiMapNode`, or just a key.
    * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
@@ -143,7 +145,10 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `add` method is returning a boolean value, which indicates whether the operation was
    * successful or not.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
@@ -186,7 +191,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
    * and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
    * array of values, or just a key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -196,7 +201,10 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
    * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);
diff --git a/test/unit/data-structures/binary-tree/avl-tree-counter.test.ts b/test/unit/data-structures/binary-tree/avl-tree-counter.test.ts
index 2cab97f..06e074a 100644
--- a/test/unit/data-structures/binary-tree/avl-tree-counter.test.ts
+++ b/test/unit/data-structures/binary-tree/avl-tree-counter.test.ts
@@ -91,7 +91,7 @@ describe('AVLTreeCounter operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -99,7 +99,7 @@ describe('AVLTreeCounter operations test1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -347,7 +347,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -355,7 +355,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -709,7 +709,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn 2', () => {
@@ -724,7 +724,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn throw error', () => {
@@ -760,7 +760,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 });
 
diff --git a/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts b/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts
index a5e9821..0e14d84 100644
--- a/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts
+++ b/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts
@@ -50,7 +50,7 @@ describe('AVLTreeMultiMap Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -176,7 +176,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -509,7 +509,7 @@ describe('AVLTreeMultiMap not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -527,7 +527,6 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     for (const i of arr) avlTmm.add([i, [i]]);
-
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -544,7 +543,7 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
diff --git a/test/unit/data-structures/binary-tree/avl-tree.test.ts b/test/unit/data-structures/binary-tree/avl-tree.test.ts
index 57dc9ce..a04630f 100644
--- a/test/unit/data-structures/binary-tree/avl-tree.test.ts
+++ b/test/unit/data-structures/binary-tree/avl-tree.test.ts
@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, Range } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -150,7 +150,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -480,7 +480,7 @@ describe('AVL Tree not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -515,7 +515,7 @@ describe('AVL Tree not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -542,3 +542,70 @@ describe('AVLTree iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toBe('c');
   });
 });
+
+describe('classic use', () => {
+  // Test case for finding elements in a given range
+  it('@example Find elements in a range', () => {
+    type Datum = { timestamp: Date; temperature: number };
+    // Fixed dataset of CPU temperature readings
+    const cpuData: Datum[] = [
+      { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+      { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+      { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+      { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+      { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+      { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+      { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+      { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+      { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+      { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+      { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+      { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+      { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+      { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+      { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+      { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+      { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+      { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+      { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+      { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+      { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+      { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+      { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+      { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+      { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+      { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+      { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+      { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+      { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+      { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+    ];
+
+    // Create an AVL tree to store CPU temperature data
+    const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+      toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+    });
+
+    // Query a specific time range (e.g., from 00:05 to 00:15)
+    const rangeStart = new Date('2024-12-02T00:05:00');
+    const rangeEnd = new Date('2024-12-02T00:15:00');
+    const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+      minute: node ? node.key.getMinutes() : 0,
+      temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+    }));
+
+    expect(rangeResults).toEqual( [
+            { minute: 5, temperature: 59.4 },
+            { minute: 6, temperature: 60.1 },
+            { minute: 7, temperature: 61.3 },
+            { minute: 8, temperature: 62 },
+            { minute: 9, temperature: 63.5 },
+            { minute: 10, temperature: 64 },
+            { minute: 11, temperature: 62.8 },
+            { minute: 12, temperature: 61.5 },
+            { minute: 13, temperature: 60.2 },
+            { minute: 14, temperature: 59.8 },
+            { minute: 15, temperature: 58.6 }
+          ]);
+  });
+});
diff --git a/test/unit/data-structures/binary-tree/binary-tree.test.ts b/test/unit/data-structures/binary-tree/binary-tree.test.ts
index c1c8d8e..eb84e7a 100644
--- a/test/unit/data-structures/binary-tree/binary-tree.test.ts
+++ b/test/unit/data-structures/binary-tree/binary-tree.test.ts
@@ -217,20 +217,20 @@ describe('BinaryTree', () => {
     expect(cloned.root?.right?.key).toBe(6);
     expect(cloned.root?.right?.left?.key).toBe(3);
     expect(cloned.root?.right?.right).toBe(null);
-    expect(cloned.dfs(node => node.key, 'PRE', cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => node.key, 'PRE', false, cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', false, cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : node), 'PRE', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : node), 'PRE', false, cloned.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', cloned.getNode(6), 'RECURSIVE', true)).toEqual([
+    expect(cloned.dfs(node => (node ? node.key : null), 'PRE', false, cloned.getNode(6), 'RECURSIVE', true)).toEqual([
       6,
       3,
       7,
@@ -532,11 +532,11 @@ describe('BinaryTree', () => {
     expect(binTree.dfs()).toEqual([]);
     expect([...binTree.values()]).toEqual([]);
     binTree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(binTree.dfs(node => node.key, 'PRE', undefined, 'ITERATIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'ITERATIVE', false)).toEqual([
-      4, 2, 1, 5, 6, 3, 7
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'ITERATIVE', true)).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, undefined, 'ITERATIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'ITERATIVE', false)).toEqual(
+      [4, 2, 1, 5, 6, 3, 7]
+    );
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'ITERATIVE', true)).toEqual([
       4,
       2,
       null,
@@ -549,11 +549,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'PRE', undefined, 'RECURSIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'RECURSIVE', false)).toEqual([
-      4, 2, 1, 5, 6, 3, 7
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', undefined, 'RECURSIVE', true)).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, undefined, 'RECURSIVE')).toEqual([4, 2, 1, 5, 6, 3, 7]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'RECURSIVE', false)).toEqual(
+      [4, 2, 1, 5, 6, 3, 7]
+    );
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, undefined, 'RECURSIVE', true)).toEqual([
       4,
       2,
       null,
@@ -566,11 +566,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'IN', undefined, 'ITERATIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'ITERATIVE', false)).toEqual([
+    expect(binTree.dfs(node => node.key, 'IN', false, undefined, 'ITERATIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'ITERATIVE', false)).toEqual([
       2, 5, 1, 4, 7, 3, 6
     ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'ITERATIVE', true)).toEqual([
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'ITERATIVE', true)).toEqual([
       null,
       2,
       5,
@@ -583,11 +583,11 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'IN', undefined, 'RECURSIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'RECURSIVE', false)).toEqual([
+    expect(binTree.dfs(node => node.key, 'IN', false, undefined, 'RECURSIVE')).toEqual([2, 5, 1, 4, 7, 3, 6]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'RECURSIVE', false)).toEqual([
       2, 5, 1, 4, 7, 3, 6
     ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', undefined, 'RECURSIVE', true)).toEqual([
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, undefined, 'RECURSIVE', true)).toEqual([
       null,
       2,
       5,
@@ -600,89 +600,71 @@ describe('BinaryTree', () => {
       null
     ]);
 
-    expect(binTree.dfs(node => node.key, 'POST', undefined, 'ITERATIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'ITERATIVE', false)).toEqual([
-      5, 1, 2, 7, 3, 6, 4
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'ITERATIVE', true)).toEqual([
-      null,
-      5,
-      null,
-      1,
-      2,
-      7,
-      3,
-      null,
-      6,
-      4
-    ]);
+    expect(binTree.dfs(node => node.key, 'POST', false, undefined, 'ITERATIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'ITERATIVE', false)
+    ).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'ITERATIVE', true)).toEqual(
+      [null, 5, null, 1, 2, 7, 3, null, 6, 4]
+    );
 
-    expect(binTree.dfs(node => node.key, 'POST', undefined, 'RECURSIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'RECURSIVE', false)).toEqual([
-      5, 1, 2, 7, 3, 6, 4
-    ]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', undefined, 'RECURSIVE', true)).toEqual([
-      null,
-      5,
-      null,
-      1,
-      2,
-      7,
-      3,
-      null,
-      6,
-      4
-    ]);
+    expect(binTree.dfs(node => node.key, 'POST', false, undefined, 'RECURSIVE')).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'RECURSIVE', false)
+    ).toEqual([5, 1, 2, 7, 3, 6, 4]);
+    expect(binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, undefined, 'RECURSIVE', true)).toEqual(
+      [null, 5, null, 1, 2, 7, 3, null, 6, 4]
+    );
   });
 
   it('should sub binTree traverse', () => {
     binTree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'ITERATIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'ITERATIVE', true)
     ).toEqual([6, 3, 7, null]);
 
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([6, 3, 7]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', binTree.getNode(6), 'RECURSIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'PRE', false, binTree.getNode(6), 'RECURSIVE', true)
     ).toEqual([6, 3, 7, null]);
 
-    expect(binTree.dfs(node => node.key, 'IN', binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'ITERATIVE', true)).toEqual(
-      [7, 3, 6, null]
-    );
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'ITERATIVE', true)
+    ).toEqual([7, 3, 6, null]);
 
-    expect(binTree.dfs(node => node.key, 'IN', binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([7, 3, 6]);
-    expect(binTree.dfs(node => (node !== null ? node.key : null), 'IN', binTree.getNode(6), 'RECURSIVE', true)).toEqual(
-      [7, 3, 6, null]
-    );
+    expect(
+      binTree.dfs(node => (node !== null ? node.key : null), 'IN', false, binTree.getNode(6), 'RECURSIVE', true)
+    ).toEqual([7, 3, 6, null]);
 
-    expect(binTree.dfs(node => node.key, 'POST', binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.getNode(6), 'ITERATIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'ITERATIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'ITERATIVE', false)
     ).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'ITERATIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'ITERATIVE', true)
     ).toEqual([7, 3, null, 6]);
 
-    expect(binTree.dfs(node => node.key, 'POST', binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.getNode(6), 'RECURSIVE')).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'RECURSIVE', false)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'RECURSIVE', false)
     ).toEqual([7, 3, 6]);
     expect(
-      binTree.dfs(node => (node !== null ? node.key : null), 'POST', binTree.getNode(6), 'RECURSIVE', true)
+      binTree.dfs(node => (node !== null ? node.key : null), 'POST', false, binTree.getNode(6), 'RECURSIVE', true)
     ).toEqual([7, 3, null, 6]);
   });
 
@@ -814,7 +796,7 @@ describe('BinaryTree Morris Traversal', () => {
 
     expect(result).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
@@ -875,7 +857,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn with initial', () => {
@@ -890,7 +872,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(expected);
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(expected);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should no toEntryFn', () => {
@@ -905,7 +887,7 @@ describe('BinaryTree toEntryFn', () => {
 
     expect(binTree.morris(node => node.key, 'IN')).toEqual(data.sort((a, b) => a.obj.id - b.obj.id));
     expect(binTree.dfs(node => node.key, 'IN')).toEqual(data);
-    expect(binTree.dfs(node => node.key, 'IN', binTree.root, 'RECURSIVE')).toEqual(data);
+    expect(binTree.dfs(node => node.key, 'IN', false, binTree.root, 'RECURSIVE')).toEqual(data);
   });
 });
 
@@ -953,19 +935,21 @@ describe('BinaryTree traversals', () => {
     );
 
     expect(binTree.dfs(node => node.key, 'PRE')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-    expect(binTree.dfs(node => node.key, 'PRE', binTree.root, 'RECURSIVE')).toEqual([
+    expect(binTree.dfs(node => node.key, 'PRE', false, binTree.root, 'RECURSIVE')).toEqual([
       35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
     ]);
     expect(
-      binTree.dfs(node => node, 'PRE', binTree.root, 'ITERATIVE', true).map(node => (node === null ? null : node.key))
+      binTree
+        .dfs(node => node, 'PRE', false, binTree.root, 'ITERATIVE', true)
+        .map(node => (node === null ? null : node.key))
     ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
     expect(
-      binTree.dfs(node => node, 'PRE', binTree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))
+      binTree.dfs(node => node, 'PRE', false, binTree.root, 'RECURSIVE', true).map(node => (node ? node.key : null))
     ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
     expect(binTree.dfs(node => node.key, 'IN')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
     expect(binTree.dfs(node => node.key, 'POST')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-    expect(binTree.dfs(node => node.key, 'POST', binTree.root, 'RECURSIVE')).toEqual([
+    expect(binTree.dfs(node => node.key, 'POST', false, binTree.root, 'RECURSIVE')).toEqual([
       16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
     ]);
     expect(binTree.bfs(node => node.key, binTree.root, 'RECURSIVE')).toEqual([
diff --git a/test/unit/data-structures/binary-tree/bst.test.ts b/test/unit/data-structures/binary-tree/bst.test.ts
index 5a27122..517d5ea 100644
--- a/test/unit/data-structures/binary-tree/bst.test.ts
+++ b/test/unit/data-structures/binary-tree/bst.test.ts
@@ -90,7 +90,7 @@ describe('BST operations test', () => {
     expect(nodes.map(node => node.key)).toEqual([15]);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -299,7 +299,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -492,7 +492,7 @@ describe('BST operations test', () => {
 
   it('should search in range', () => {
     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(bst.rangeSearch([4, 12])).toEqual([10, 12, 5, 7]);
+    expect(bst.rangeSearch([4, 12])).toEqual([5, 7, 10, 12]);
     expect(() => bst.rangeSearch([12, 4])).toThrow('low must be less than or equal to high');
     expect(bst.rangeSearch([12, 12])).toEqual([12]);
   });
@@ -535,7 +535,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -742,7 +742,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -1080,10 +1080,10 @@ describe('BST Performance test', function () {
   it('should dfs as sub tree traversal, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(bst.dfs(node => node.key, 'PRE', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node.key, 'PRE', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'PRE', false, bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'PRE', false, bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', false, bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'PRE', false, bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
   });
 });
 
@@ -1565,9 +1565,9 @@ describe('classic use', () => {
   // Test case for finding elements in a given range
   it('@example Find elements in a range', () => {
     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(bst.search(new Range(5, 10))).toEqual([10, 5, 7]);
-    expect(bst.rangeSearch([4, 12], node => node.key.toString())).toEqual(['10', '12', '5', '7']);
-    expect(bst.search(new Range(4, 12, true, false))).toEqual([10, 5, 7]);
+    expect(bst.search(new Range(5, 10))).toEqual([5, 7, 10]);
+    expect(bst.rangeSearch([4, 12], node => node.key.toString())).toEqual(['5', '7', '10', '12']);
+    expect(bst.search(new Range(4, 12, true, false))).toEqual([5, 7, 10]);
     expect(bst.rangeSearch([15, 20])).toEqual([15, 18]);
     expect(bst.search(new Range(15, 20, false))).toEqual([18]);
   });
diff --git a/test/unit/data-structures/binary-tree/red-black-tree.test.ts b/test/unit/data-structures/binary-tree/red-black-tree.test.ts
index 9bc5e22..43a12ca 100644
--- a/test/unit/data-structures/binary-tree/red-black-tree.test.ts
+++ b/test/unit/data-structures/binary-tree/red-black-tree.test.ts
@@ -504,11 +504,11 @@ describe('RedBlackTree 2', () => {
     expect(rbTree.isBST()).toBe(true);
     expect(rbTree.isBST(rbTree.root, 'RECURSIVE')).toBe(true);
 
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'ITERATIVE')).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'ITERATIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'RECURSIVE')).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'RECURSIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
@@ -524,7 +524,7 @@ describe('RedBlackTree 2', () => {
 
     expect(rbTree.size).toBe(0);
     expect(rbTree.isBST()).toBe(true);
-    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'ITERATIVE')).toEqual([]);
+    expect(rbTree.dfs(n => n.key, 'IN', false, rbTree.root, 'ITERATIVE')).toEqual([]);
 
     rbTree.clear();
     for (let i = 0; i < 1000; i++) {
@@ -838,14 +838,6 @@ describe('real world data', () => {
 });
 
 describe('classic use', () => {
-  // Test case for finding elements in a given range
-  it('@example Find elements in a range', () => {
-    const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(bst.search(new Range(5, 10))).toEqual([5, 10, 7]);
-    expect(bst.search(new Range(4, 12))).toEqual([5, 10, 12, 7]);
-    expect(bst.search(new Range(15, 20))).toEqual([15, 18]);
-  });
-
   it('@example using Red-Black Tree as a price-based index for stock data', () => {
     // Define the structure of individual stock records
     interface StockRecord {
@@ -887,6 +879,6 @@ describe('classic use', () => {
       [200, 400], // Price range
       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
     );
-    expect(stocksInRange).toEqual(['GOOGL', 'MSFT', 'META']); // Verify stocks in the range
+    expect(stocksInRange).toEqual(['GOOGL', 'META', 'MSFT']); // Verify stocks in the range
   });
 });
diff --git a/test/unit/data-structures/binary-tree/tree-counter.test.ts b/test/unit/data-structures/binary-tree/tree-counter.test.ts
index 42bec96..8eeac1b 100644
--- a/test/unit/data-structures/binary-tree/tree-counter.test.ts
+++ b/test/unit/data-structures/binary-tree/tree-counter.test.ts
@@ -149,7 +149,7 @@ describe('TreeCounter operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     treeCounter.lesserOrGreaterTraverse(node => (lesserSum += node.key), -1, 10);
@@ -157,7 +157,7 @@ describe('TreeCounter operations test1', () => {
 
     expect(node15 instanceof TreeCounterNode);
     if (node15 instanceof TreeCounterNode) {
-      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = treeCounter.getNode(11);
@@ -407,7 +407,7 @@ describe('TreeCounter operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) treeCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     expect(treeCounter.has(9)).toBe(true);
@@ -423,7 +423,7 @@ describe('TreeCounter operations test recursively1', () => {
 
     expect(node15 instanceof TreeCounterNode);
     if (node15 instanceof TreeCounterNode) {
-      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = treeCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = treeCounter.getNode(11);
diff --git a/test/unit/data-structures/binary-tree/tree-multi-map.test.ts b/test/unit/data-structures/binary-tree/tree-multi-map.test.ts
index fa50657..1638e25 100644
--- a/test/unit/data-structures/binary-tree/tree-multi-map.test.ts
+++ b/test/unit/data-structures/binary-tree/tree-multi-map.test.ts
@@ -519,11 +519,11 @@ describe('TreeMultiMap 2', () => {
     expect(tmm.isBST()).toBe(true);
     expect(tmm.isBST(tmm.root, 'RECURSIVE')).toBe(true);
 
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'ITERATIVE')).toEqual([
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'ITERATIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'RECURSIVE')).toEqual([
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'RECURSIVE')).toEqual([
       49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
       77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
@@ -539,7 +539,7 @@ describe('TreeMultiMap 2', () => {
 
     expect(tmm.size).toBe(0);
     expect(tmm.isBST()).toBe(true);
-    expect(tmm.dfs(n => n.key, 'IN', tmm.root, 'ITERATIVE')).toEqual([]);
+    expect(tmm.dfs(n => n.key, 'IN', false, tmm.root, 'ITERATIVE')).toEqual([]);
 
     tmm.clear();
     for (let i = 0; i < 1000; i++) {
@@ -840,8 +840,8 @@ describe('classic use', () => {
   // Test case for finding elements in a given range
   it('@example Find elements in a range', () => {
     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(tmm.search(new Range(5, 10))).toEqual([5, 10, 7]);
-    expect(tmm.search(new Range(4, 12))).toEqual([5, 10, 12, 7]);
+    expect(tmm.search(new Range(5, 10))).toEqual([5, 7, 10]);
+    expect(tmm.search(new Range(4, 12))).toEqual([5, 7, 10, 12]);
     expect(tmm.search(new Range(15, 20))).toEqual([15, 18]);
   });
 });