data-structure-typed 1.49.3 → 1.49.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.49.3",
+  "version": "1.49.5",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -14,11 +14,12 @@
     }
   },
   "scripts": {
-    "build": "npm run build:mjs && npm run build:cjs && npm run build:umd && npm run build:docs",
+    "build": "npm run build:mjs && npm run build:cjs && npm run build:umd && npm run build:docs-class",
     "build:mjs": "rm -rf dist/mjs && tsc -p tsconfig-mjs.json",
     "build:cjs": "rm -rf dist/cjs && tsc -p tsconfig-cjs.json",
     "build:umd": "tsup",
     "build:docs": "typedoc --out docs ./src",
+    "build:docs-class": "typedoc --out docs ./src/data-structures",
     "test:unit": "jest --runInBand",
     "test": "npm run test:unit",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
@@ -87,7 +88,7 @@
     "ts-loader": "^9.4.4",
     "ts-node": "^10.9.1",
     "tsup": "^7.2.0",
-    "typedoc": "^0.25.1",
+    "typedoc": "^0.25.4",
     "typescript": "^5.3.2"
   },
   "keywords": [

package/src/data-structures/base/index.ts

@@ -1 +1 @@
-export * from './iterable-base';
+export * from './iterable-base';

package/src/data-structures/base/iterable-base.ts

@@ -1,7 +1,6 @@
-import { ElementCallback, EntryCallback, ReduceElementCallback, ReduceEntryCallback } from "../../types";
+import { ElementCallback, EntryCallback, ReduceElementCallback, ReduceEntryCallback } from '../../types';
 
 export abstract class IterableEntryBase<K = any, V = any> {
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -147,7 +146,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      callbackfn.call(thisArg, value, key, index++, this)
+      callbackfn.call(thisArg, value, key, index++, this);
     }
   }
 
@@ -176,7 +175,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
     let index = 0;
     for (const item of this) {
       const [key, value] = item;
-      accumulator = callbackfn(accumulator, value, key, index++, this)
+      accumulator = callbackfn(accumulator, value, key, index++, this);
     }
     return accumulator;
   }
@@ -193,14 +192,13 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * Space Complexity: O(n)
    */
   print(): void {
-    console.log([...this])
+    console.log([...this]);
   }
 
   protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 
 export abstract class IterableElementBase<V> {
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -310,7 +308,7 @@ export abstract class IterableElementBase<V> {
   forEach(callbackfn: ElementCallback<V, void>, thisArg?: any): void {
     let index = 0;
     for (const item of this) {
-      callbackfn.call(thisArg, item as V, index++, this)
+      callbackfn.call(thisArg, item as V, index++, this);
     }
   }
 
@@ -335,18 +333,17 @@ export abstract class IterableElementBase<V> {
     let accumulator = initialValue;
     let index = 0;
     for (const item of this) {
-      accumulator = callbackfn(accumulator, item as V, index++, this)
+      accumulator = callbackfn(accumulator, item as V, index++, this);
     }
     return accumulator;
   }
 
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
   print(): void {
-    console.log([...this])
+    console.log([...this]);
   }
 
   protected abstract _getIterator(...args: any[]): IterableIterator<V>;

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

@@ -18,7 +18,11 @@ import type {
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
-export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
+export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<
+  K,
+  V,
+  N
+> {
   height: number;
 
   constructor(key: K, value?: V) {
@@ -36,10 +40,14 @@ export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLT
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
-export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>, TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>>
+export class AVLTree<
+  K = any,
+  V = any,
+  N extends AVLTreeNode<K, V, N> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
+  TREE extends AVLTree<K, V, N, TREE> = AVLTree<K, V, N, AVLTreeNested<K, V, N>>
+>
   extends BST<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
-
   /**
    * The constructor function initializes an AVLTree object with optional elements and options.
    * @param [elements] - The `elements` parameter is an optional iterable of `BTNExemplar<K, V, N>`
@@ -77,7 +85,8 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
   override createTree(options?: AVLTreeOptions<K>): TREE {
     return new AVLTree<K, V, N, TREE>([], {
       iterationType: this.iterationType,
-      variant: this.variant, ...options
+      variant: this.variant,
+      ...options
     }) as TREE;
   }
 
@@ -97,7 +106,7 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
   override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof AVLTreeNode)
+    return !(potentialKey instanceof AVLTreeNode);
   }
 
   /**
@@ -105,7 +114,6 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
    */
 
-
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -159,7 +167,6 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
     return deletedResults;
   }
 
-
   /**
    * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
    * tree.
@@ -489,6 +496,6 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
   protected _replaceNode(oldNode: N, newNode: N): N {
     newNode.height = oldNode.height;
 
-    return super._replaceNode(oldNode, newNode)
+    return super._replaceNode(oldNode, newNode);
   }
 }

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

@@ -24,14 +24,18 @@ import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
-import { IterableEntryBase } from "../base";
+import { IterableEntryBase } from '../base';
 
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
  * @template N - The type of the family relationship in the binary tree.
  */
-export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>> {
+export class BinaryTreeNode<
+  K = any,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>
+> {
   key: K;
 
   value?: V;
@@ -97,10 +101,15 @@ export class BinaryTreeNode<K = any, V = any, N extends BinaryTreeNode<K, V, N>
  * 5. Leaf Nodes: Nodes without children are leaves.
  */
 
-export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>> extends IterableEntryBase<K, V | undefined>
-
+export class BinaryTree<
+  K = any,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
+  TREE extends BinaryTree<K, V, N, TREE> = BinaryTree<K, V, N, BinaryTreeNested<K, V, N>>
+>
+  extends IterableEntryBase<K, V | undefined>
   implements IBinaryTree<K, V, N, TREE> {
-  iterationType = IterationType.ITERATIVE
+  iterationType = IterationType.ITERATIVE;
 
   /**
    * The constructor function initializes a binary tree object with optional elements and options.
@@ -128,7 +137,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     if (elements) this.addMany(elements);
   }
 
-  protected _extractor = (key: K) => Number(key)
+  protected _extractor = (key: K) => Number(key);
 
   get extractor() {
     return this._extractor;
@@ -287,7 +296,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     return undefined; // If the insertion position cannot be found, return undefined
   }
 
-
   /**
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
@@ -329,7 +337,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     return inserted;
   }
 
-
   /**
    * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
    * Space Complexity: O(1)
@@ -985,10 +992,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
    * is no leftmost node, it returns `null` or `undefined` depending on the input.
    */
-  getLeftMost(
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
-    iterationType = this.iterationType
-  ): N | null | undefined {
+  getLeftMost(beginRoot: BTNKeyOrNode<K, N> = this.root, iterationType = this.iterationType): N | null | undefined {
     beginRoot = this.ensureNode(beginRoot);
 
     if (!beginRoot) return beginRoot;
@@ -1031,10 +1035,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
    * is no rightmost node, it returns `null` or `undefined`, depending on the input.
    */
-  getRightMost(
-    beginRoot: BTNKeyOrNode<K, N> = this.root,
-    iterationType = this.iterationType
-  ): N | null | undefined {
+  getRightMost(beginRoot: BTNKeyOrNode<K, N> = this.root, iterationType = this.iterationType): N | null | undefined {
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
@@ -1262,7 +1263,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
   isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof BinaryTreeNode)
+    return !(potentialKey instanceof BinaryTreeNode);
   }
 
   dfs<C extends BTNCallback<N>>(
@@ -1637,7 +1638,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * after the given node in the inorder traversal of the binary tree.
    */
   getSuccessor(x?: K | N | null): N | null | undefined {
-
     x = this.ensureNode(x);
     if (!this.isRealNode(x)) return undefined;
 
@@ -1858,11 +1858,14 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;
 
-    if (opts.isShowUndefined) console.log(`U for undefined
+    if (opts.isShowUndefined)
+      console.log(`U for undefined
       `);
-    if (opts.isShowNull) console.log(`N for null
+    if (opts.isShowNull)
+      console.log(`N for null
       `);
-    if (opts.isShowRedBlackNIL) console.log(`S for Sentinel Node
+    if (opts.isShowRedBlackNIL)
+      console.log(`S for Sentinel Node
       `);
 
     const display = (root: N | null | undefined): void => {
@@ -1920,30 +1923,42 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     } else if (node !== null && node !== undefined) {
       // Display logic of normal nodes
 
-      const key = node.key, line = isNaN(this.extractor(key)) ? 'S' : this.extractor(key).toString(),
+      const key = node.key,
+        line = isNaN(this.extractor(key)) ? 'S' : this.extractor(key).toString(),
         width = line.length;
 
-      return _buildNodeDisplay(line, width, this._displayAux(node.left, options), this._displayAux(node.right, options))
-
+      return _buildNodeDisplay(
+        line,
+        width,
+        this._displayAux(node.left, options),
+        this._displayAux(node.right, options)
+      );
     } else {
       // For cases where none of the conditions are met, null, undefined, and NaN nodes are not displayed
-      const line = node === undefined ? 'U' : 'N', width = line.length;
+      const line = node === undefined ? 'U' : 'N',
+        width = line.length;
 
-      return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0])
+      return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
     }
 
     function _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
       const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
       const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
-      const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
-        + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
-        + line
-        + '_'.repeat(Math.max(0, rightMiddle))
-        + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
-
-      const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
-        + ' '.repeat(width)
-        + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+      const firstLine =
+        ' '.repeat(Math.max(0, leftMiddle + 1)) +
+        '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1)) +
+        line +
+        '_'.repeat(Math.max(0, rightMiddle)) +
+        ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+
+      const secondLine =
+        (leftHeight > 0
+          ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1)
+          : ' '.repeat(leftWidth)) +
+        ' '.repeat(width) +
+        (rightHeight > 0
+          ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1)
+          : ' '.repeat(rightWidth));
 
       const mergedLines = [firstLine, secondLine];
 
@@ -1953,11 +1968,16 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
         mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
       }
 
-      return <NodeDisplayLayout>[mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+      return <NodeDisplayLayout>[
+        mergedLines,
+        leftWidth + width + rightWidth,
+        Math.max(leftHeight, rightHeight) + 2,
+        leftWidth + Math.floor(width / 2)
+      ];
     }
   }
 
-  protected _defaultOneParamCallback = (node: N) => node.key;
+  protected _defaultOneParamCallback = (node: N | null | undefined) => (node ? node.key : undefined);
 
   /**
    * Swap the data of two nodes in the binary tree.
@@ -2012,43 +2032,6 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     return newNode;
   }
 
-  /**
-   * The function `_addTo` adds a new node to a binary tree if there is an available position.
-   * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
-   * the binary tree. It can be either a node object or `null`.
-   * @param {N} parent - The `parent` parameter represents the parent node to which the new node will
-   * be added as a child.
-   * @returns either the left or right child node of the parent node, depending on which child is
-   * available for adding the new node. If a new node is added, the function also updates the size of
-   * the binary tree. If neither the left nor right child is available, the function returns undefined.
-   * If the parent node is null, the function also returns undefined.
-   */
-  protected _addTo(newNode: N | null | undefined, parent: BTNKeyOrNode<K, N>): N | null | undefined {
-    if (this.isNotNodeInstance(parent)) parent = this.getNode(parent);
-
-    if (parent) {
-      // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
-      // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
-      if (parent.left === undefined) {
-        parent.left = newNode;
-        if (newNode) {
-          this._size = this.size + 1;
-        }
-        return parent.left;
-      } else if (parent.right === undefined) {
-        parent.right = newNode;
-        if (newNode) {
-          this._size = this.size + 1;
-        }
-        return parent.right;
-      } else {
-        return;
-      }
-    } else {
-      return;
-    }
-  }
-
   /**
    * The function sets the root property of an object to a given value, and if the value is not null,
    * it also sets the parent property of the value to undefined.

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

@@ -20,7 +20,11 @@ import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 
-export class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
+export class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<
+  K,
+  V,
+  N
+> {
   override parent?: N;
 
   constructor(key: K, value?: V) {
@@ -80,11 +84,14 @@ export class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNeste
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
-export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>>
+export class BST<
+  K = any,
+  V = any,
+  N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>,
+  TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>
+>
   extends BinaryTree<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
-
-
   /**
    * This is the constructor function for a binary search tree class in TypeScript, which initializes
    * the tree with optional elements and options.
@@ -114,7 +121,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return this._root;
   }
 
-  protected _variant = BSTVariant.MIN
+  protected _variant = BSTVariant.MIN;
 
   get variant() {
     return this._variant;
@@ -142,7 +149,8 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   override createTree(options?: Partial<BSTOptions<K>>): TREE {
     return new BST<K, V, N, TREE>([], {
       iterationType: this.iterationType,
-      variant: this.variant, ...options
+      variant: this.variant,
+      ...options
     }) as TREE;
   }
 
@@ -155,7 +163,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return exemplar instanceof BSTNode;
   }
 
-
   /**
    * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
    * otherwise it returns undefined.
@@ -301,7 +308,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     const isRealBTNExemplar = (kve: BTNExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
       if (kve === undefined || kve === null) return false;
       return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
-    }
+    };
 
     for (const kve of keysOrNodesOrEntries) {
       isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
@@ -359,7 +366,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return inserted;
   }
 
-
   /**
    * 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.
@@ -398,7 +404,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return current.key;
   }
 
-
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree.
    * Space Complexity: O(1) - Constant space is used.
@@ -450,7 +455,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
   override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof BSTNode)
+    return !(potentialKey instanceof BSTNode);
   }
 
   /**
@@ -738,7 +743,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return balanced;
   }
 
-
   protected _setRoot(v: N | undefined) {
     if (v) {
       v.parent = undefined;
@@ -761,5 +765,4 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
 
     return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
   }
-
 }

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

@@ -21,10 +21,11 @@ import {
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
-export class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<
-  K, V,
-  N
-> {
+export class RedBlackTreeNode<
+  K = any,
+  V = any,
+  N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>
+> extends BSTNode<K, V, N> {
   color: RBTNColor;
 
   constructor(key: K, value?: V, color: RBTNColor = RBTNColor.BLACK) {
@@ -40,7 +41,12 @@ export class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V,
  * 4. Red nodes must have black children.
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
-export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>>
+export class RedBlackTree<
+  K = any,
+  V = any,
+  N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
+  TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>
+>
   extends BST<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
   Sentinel: N = new RedBlackTreeNode<K, V>(NaN as K) as unknown as N;
@@ -101,7 +107,8 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   override createTree(options?: RBTreeOptions<K>): TREE {
     return new RedBlackTree<K, V, N, TREE>([], {
       iterationType: this.iterationType,
-      variant: this.variant, ...options
+      variant: this.variant,
+      ...options
     }) as TREE;
   }
 
@@ -122,7 +129,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
   override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof RedBlackTreeNode)
+    return !(potentialKey instanceof RedBlackTreeNode);
   }
 
   /**
@@ -191,12 +198,11 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
           x = x?.right;
         } else {
           if (newNode !== x) {
-            this._replaceNode(x, newNode)
+            this._replaceNode(x, newNode);
           }
           return;
         }
       }
-
     }
 
     newNode.parent = y;
@@ -649,6 +655,6 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   protected _replaceNode(oldNode: N, newNode: N): N {
     newNode.color = oldNode.color;
 
-    return super._replaceNode(oldNode, newNode)
+    return super._replaceNode(oldNode, newNode);
   }
 }