graph-typed 1.43.1 → 1.43.3

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

@@ -21,8 +21,7 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
 
 export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -114,7 +113,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected override _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N  | undefined): N | undefined {
+  protected override _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined {
     srcNode = this.ensureNotKey(srcNode);
     destNode = this.ensureNotKey(destNode);
 

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

@@ -107,8 +107,7 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N> {
+export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -301,7 +300,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   ): BiTreeDeleteResult<N>[] {
     const deletedResult: BiTreeDeleteResult<N>[] = [];
     if (!this.root) return deletedResult;
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+      callback = (node => node) as C;
 
     const curr = this.getNode(identifier, callback);
     if (!curr) return deletedResult;
@@ -330,14 +330,12 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
           orgCurrent = this._swap(curr, leftSubTreeRightMost);
           if (parentOfLeftSubTreeMax) {
-            if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-              parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+            if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
             else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
             needBalanced = parentOfLeftSubTreeMax;
           }
         }
       }
-
     }
     this._size = this.size - 1;
 
@@ -383,7 +381,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
    */
 
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(log n)
@@ -412,7 +409,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
       return _getMaxHeight(beginRoot);
     } else {
-      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
+      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -539,7 +536,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * Space Complexity: O(log n).
    */
 
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(log n).
@@ -572,7 +568,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null | undefined = this.root,
     iterationType = this.iterationType
   ): N[] {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+      callback = (node => node) as C;
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return [];
 
@@ -660,7 +657,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null | undefined = this.root,
     iterationType = this.iterationType
   ): boolean {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+      callback = (node => node) as C;
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
@@ -718,7 +716,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null | undefined = this.root,
     iterationType = this.iterationType
   ): N | null | undefined {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+      callback = (node => node) as C;
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
@@ -836,7 +835,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot: BTNKey | N | null | undefined = this.root,
     iterationType = this.iterationType
   ): V | undefined {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+      callback = (node => node) as C;
 
     return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
   }
@@ -1165,7 +1165,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
    * @returns a boolean value.
    */
-  isNodeOrNull(node: any): node is (N | null) {
+  isNodeOrNull(node: any): node is N | null {
     return this.isRealNode(node) || node === null;
   }
 
@@ -1238,7 +1238,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType: IterationType = IterationType.ITERATIVE,
     includeNull = false
   ): ReturnType<C>[] {
-
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return [];
     const ans: ReturnType<C>[] = [];
@@ -1285,7 +1284,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
+      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -1454,7 +1453,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * Space complexity: O(n)
    */
 
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -1523,8 +1521,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return levelsNodes;
   }
 
-  getPredecessor(node: N): N
-
+  getPredecessor(node: N): N;
 
   /**
    * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
@@ -1549,7 +1546,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
   }
 
-
   /**
    * The function `getSuccessor` returns the next node in a binary tree given a current node.
    * @param {BTNKey | N | null} [x] - The parameter `x` can be of type `BTNKey`, `N`, or `null`.
@@ -1681,7 +1677,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
-
   /**
    * The above function is an iterator for a binary tree that can be used to traverse the tree in
    * either an iterative or recursive manner.
@@ -1691,7 +1686,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }
@@ -1722,6 +1717,74 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
   }
 
+  /**
+   * The `print` function is used to display a binary tree structure in a visually appealing way.
+   * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+   * undefined`. It represents the root node of a binary tree. The root node can have one of the
+   * following types:
+   */
+  print(beginRoot: BTNKey | N | null | undefined = this.root): void {
+    beginRoot = this.ensureNotKey(beginRoot);
+    if (!beginRoot) return;
+
+    const display = (root: N | null | undefined): void => {
+      const [lines, , ,] = _displayAux(root);
+      for (const line of lines) {
+        console.log(line);
+      }
+    };
+
+    const _displayAux = (node: N | null | undefined): [string[], number, number, number] => {
+      if (!this.isRealNode(node)) {
+        return [[], 0, 0, 0];
+      }
+
+      if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
+        const line = `${node.key}`;
+        const width = line.length;
+        const height = 1;
+        const middle = Math.floor(width / 2);
+        return [[line], width, height, middle];
+      }
+
+      if (this.isRealNode(node) && !this.isRealNode(node.right)) {
+        const [lines, n, p, x] = _displayAux(node.left);
+        const s = `${node.key}`;
+        const u = s.length;
+        const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+        const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+        const shifted_lines = lines.map(line => line + ' '.repeat(u));
+        return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+      }
+
+      if (this.isRealNode(node) && !this.isRealNode(node.left)) {
+        const [lines, n, p, u] = _displayAux(node.right);
+        const s = `${node.key}`;
+        const x = s.length;
+        const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+        const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+        const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+        return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+      }
+
+      const [left, n, p, x] = _displayAux(node.left);
+      const [right, m, q, y] = _displayAux(node.right);
+      const s = `${node.key}`;
+      const u = s.length;
+      const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+      const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+      if (p < q) {
+        left.push(...new Array(q - p).fill(' '.repeat(n)));
+      } else if (q < p) {
+        right.push(...new Array(p - q).fill(' '.repeat(m)));
+      }
+      const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+      return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+    };
+
+    display(beginRoot);
+  }
+
   protected _defaultOneParamCallback = (node: N) => node.key;
 
   /**
@@ -1749,7 +1812,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       return destNode;
     }
     return undefined;
-
   }
 
   /**
@@ -1801,73 +1863,4 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
     this._root = v;
   }
-
-
-  /**
-   * The `print` function is used to display a binary tree structure in a visually appealing way.
-   * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
-   * undefined`. It represents the root node of a binary tree. The root node can have one of the
-   * following types:
-   */
-  print(beginRoot: BTNKey | N | null | undefined = this.root): void {
-    beginRoot = this.ensureNotKey(beginRoot);
-    if (!beginRoot) return;
-
-    const display = (root: N | null | undefined): void => {
-      const [lines, , ,] = _displayAux(root);
-      for (const line of lines) {
-        console.log(line);
-      }
-    };
-
-    const _displayAux = (node: N | null | undefined): [string[], number, number, number] => {
-      if (!this.isRealNode(node)) {
-        return [[], 0, 0, 0];
-      }
-
-      if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-        const line = `${node.key}`;
-        const width = line.length;
-        const height = 1;
-        const middle = Math.floor(width / 2);
-        return [[line], width, height, middle];
-      }
-
-      if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-        const [lines, n, p, x] = _displayAux(node.left);
-        const s = `${node.key}`;
-        const u = s.length;
-        const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-        const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-        const shifted_lines = lines.map(line => line + ' '.repeat(u));
-        return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-      }
-
-      if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-        const [lines, n, p, u] = _displayAux(node.right);
-        const s = `${node.key}`;
-        const x = s.length;
-        const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-        const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-        const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-        return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-      }
-
-      const [left, n, p, x] = _displayAux(node.left);
-      const [right, m, q, y] = _displayAux(node.right);
-      const s = `${node.key}`;
-      const u = s.length;
-      const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-      const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-      if (p < q) {
-        left.push(...new Array(q - p).fill(' '.repeat(n)));
-      } else if (q < p) {
-        right.push(...new Array(p - q).fill(' '.repeat(m)));
-      }
-      const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-      return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-    };
-
-    display(beginRoot);
-  }
 }

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

@@ -12,7 +12,7 @@ import {IBinaryTree} from '../../interfaces';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  override parent?: N ;
+  override parent?: N;
 
   constructor(key: BTNKey, value?: V) {
     super(key, value);
@@ -21,7 +21,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
     this._right = undefined;
   }
 
-  protected override _left?: N ;
+  protected override _left?: N;
 
   /**
    * Get the left child node.
@@ -41,8 +41,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
     this._left = v;
   }
 
-
-  protected override _right?: N ;
+  protected override _right?: N;
 
   /**
    * Get the right child node.
@@ -63,10 +62,7 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
-  extends BinaryTree<V, N>
-  implements IBinaryTree<V, N> {
-
+export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree with an optional comparator function.
    * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -83,7 +79,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
   }
 
-  protected override _root?: N ;
+  protected override _root?: N;
 
   /**
    * Get the root node of the binary tree.
@@ -109,11 +105,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * Space Complexity: O(1) - Constant space is used.
    */
 
-
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
    * Space Complexity: O(1) - Constant space is used.
-   * 
+   *
    * The `add` function adds a new node to a binary search tree based on the provided key and value.
    * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
    * following types:
@@ -193,7 +188,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
    * Space Complexity: O(n) - Additional space is required for the sorted array.
    */
-  
+
   /**
    * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
    * Space Complexity: O(n) - Additional space is required for the sorted array.
@@ -228,12 +223,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
       return super.addMany(keysOrNodes, data).map(n => n ?? undefined);
     }
-    
+
     const inserted: (N | undefined)[] = [];
-    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
-      (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
-    );
-    
+    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map((value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]);
+
     let sorted = [];
 
     function _isNodeOrUndefinedTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
@@ -244,7 +237,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     const _isBinaryTreeKeyOrNullTuple = (arr: [BTNKey | N, V][]): arr is [BTNKey, V][] => {
       for (const [keyOrNode] of arr) if (this.isNodeKey(keyOrNode)) return true;
       return false;
-    }
+    };
 
     let sortedKeysOrNodes: (number | N | undefined)[] = [],
       sortedData: (V | undefined)[] | undefined = [];
@@ -344,7 +337,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       const _dfs = (cur: N): N | undefined => {
         if (cur.key === key) return cur;
         if (!cur.left && !cur.right) return;
-        
+
         if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
         if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
       };
@@ -380,7 +373,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
    * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
    */
-  
+
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
    * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -580,7 +573,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            debugger
+            debugger;
             this.add(midNode.key, midNode.value);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
@@ -672,5 +665,4 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     else if (compared < 0) return CP.lt;
     else return CP.eq;
   }
-
 }

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

@@ -6,21 +6,14 @@
  * @license MIT License
  */
 
-import {
-  BiTreeDeleteResult,
-  BTNCallback,
-  BTNKey,
-  IterationType,
-  RBTNColor,
-  RedBlackTreeNodeNested,
-  RBTreeOptions
-} from '../../types';
-import {BST, BSTNode} from "./bst";
-import {IBinaryTree} from "../../interfaces";
-import {BinaryTreeNode} from "./binary-tree";
+import {BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNodeNested} from '../../types';
+import {BST, BSTNode} from './bst';
+import {IBinaryTree} from '../../interfaces';
+import {BinaryTreeNode} from './binary-tree';
 
 export class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
   color: RBTNColor;
+
   constructor(key: BTNKey, value?: V, color: RBTNColor = RBTNColor.BLACK) {
     super(key, value);
     this.color = color;
@@ -36,8 +29,8 @@ export class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBla
  */
 export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
+  NIL: N = new RedBlackTreeNode<V>(NaN) as unknown as N;
 
   /**
    * The constructor function initializes a Red-Black Tree with an optional set of options.
@@ -61,8 +54,6 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     return this._size;
   }
 
-  NIL: N = new RedBlackTreeNode<V>(NaN) as unknown as N;
-
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
@@ -83,7 +74,7 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     let node: N;
     if (this.isNodeKey(keyOrNode)) {
       node = this.createNode(keyOrNode, value, RBTNColor.RED);
-    } else if(keyOrNode instanceof RedBlackTreeNode) {
+    } else if (keyOrNode instanceof RedBlackTreeNode) {
       node = keyOrNode;
     } else if (keyOrNode === null) {
       return;
@@ -226,21 +217,21 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     callback?: C,
     beginRoot?: N | undefined,
     iterationType?: IterationType
-  ): N  | undefined;
+  ): N | undefined;
 
   getNode<C extends BTNCallback<N, N>>(
     identifier: N | undefined,
     callback?: C,
     beginRoot?: N | undefined,
     iterationType?: IterationType
-  ): N  | undefined;
+  ): N | undefined;
 
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
     beginRoot?: N | undefined,
     iterationType?: IterationType
-  ): N  | undefined;
+  ): N | undefined;
 
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)