min-heap-typed 1.50.0 → 1.50.2

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BinaryTreeDeleteResult, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
+export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     color: RBTNColor;
     constructor(key: K, value?: V, color?: RBTNColor);
 }
@@ -19,12 +19,12 @@ export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNo
  * 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 declare 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;
+export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, NODE, TREE> = RedBlackTree<K, V, NODE, RedBlackTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+    Sentinel: NODE;
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -32,9 +32,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: RBTreeOptions<K>);
-    protected _root: N;
-    get root(): N;
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
+    protected _root: NODE;
+    get root(): NODE;
     protected _size: number;
     get size(): number;
     /**
@@ -49,7 +49,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key: K, value?: V, color?: RBTNColor): N;
+    createNode(key: K, value?: V, color?: RBTNColor): NODE;
     /**
      * The function creates a Red-Black Tree with the specified options and returns it.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -59,30 +59,26 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      */
     createTree(options?: RBTreeOptions<K>): TREE;
     /**
-     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
+     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
-     * @returns a node of type N or undefined.
+     * @returns a node of type NODE or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): N | undefined;
+    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    isRealNode(node: N | undefined): node is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
+    isRealNode(node: NODE | undefined): node is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
+     * On average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -94,13 +90,12 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * entry.
      * @param {V} [value] - The `value` parameter represents the value associated with the key that is
      * being added to the binary search tree.
-     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
+     * @returns The method `add` returns either the newly added node (`NODE`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -112,15 +107,12 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * that you want to use to identify the node that you want to delete from the binary tree. It can be
      * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
      * you don't want to
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<N>[];
-    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
-    getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -129,18 +121,44 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function returns the predecessor of a given node in a red-black tree.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
-     * Red-Black Tree.
-     * @returns the predecessor of the given RedBlackTreeNode 'x'.
-     */
-    getPredecessor(x: N): N;
+     * The function `getNode` retrieves a single node from a binary tree based on a given identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value used to
+     * identify the node you want to retrieve. It can be of any type that is the return type of the `C`
+     * callback function. If the `identifier` is `undefined`, it means you want to retrieve the first
+     * node that matches the other criteria
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
+     * provided, the search will start from the root of the binary tree.
+     * @param iterationType - The `iterationType` parameter is a variable that determines the type of
+     * iteration to be performed when searching for nodes in the binary tree. It is used in the
+     * `getNodes` method, which is called within the `getNode` method.
+     * @returns a value of type `NODE`, `null`, or `undefined`.
+     */
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: import("../../types").IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     clear(): void;
-    protected _setRoot(v: N): void;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function returns the predecessor of a given node in a red-black tree.
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
+     * Red-Black Tree.
+     * @returns the predecessor of the given RedBlackTreeNode 'x'.
+     */
+    getPredecessor(x: NODE): NODE;
+    protected _setRoot(v: NODE): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -150,9 +168,9 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Space Complexity: O(1)
      *
      * The function performs a left rotation on a binary tree node.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `N`, which likely represents a node in a binary tree.
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `NODE`, which likely represents a node in a binary tree.
      */
-    protected _leftRotate(x: N): void;
+    protected _leftRotate(x: NODE): void;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -165,7 +183,7 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
      * rotated.
      */
-    protected _rightRotate(x: N): void;
+    protected _rightRotate(x: NODE): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -174,44 +192,44 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
-     * @param {RedBlackTreeNode} x - The parameter `x` represents a node in a Red-Black Tree (RBT).
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
+     * red-black tree.
      */
-    protected _fixDelete(x: N): void;
+    protected _fixInsert(k: NODE): void;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
-     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
+     * The function `_fixDelete` is used to fix the red-black tree after a node deletion.
+     * @param {RedBlackTreeNode} x - The parameter `x` represents a node in a Red-Black Tree (RBT).
      */
-    protected _rbTransplant(u: N, v: N): void;
+    protected _fixDelete(x: NODE): void;
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
-     * red-black tree.
+     * The function `_rbTransplant` replaces one node in a red-black tree with another node.
+     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
+     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
      */
-    protected _fixInsert(k: N): void;
+    protected _rbTransplant(u: NODE, v: NODE): void;
     /**
      * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
-     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `NODE`, which is the type of the nodes in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, passing in the `oldNode` and `newNode` as arguments.
      */
-    protected _replaceNode(oldNode: N, newNode: N): N;
+    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

package/dist/data-structures/binary-tree/rb-tree.js

@@ -28,7 +28,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
-     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+     * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, NODE>`
      * objects. It represents the initial nodes that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * nodes to the
@@ -76,14 +76,14 @@ class RedBlackTree extends bst_1.BST {
         return new RedBlackTree([], Object.assign({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function `exemplarToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
+     * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and converts it into a node object if possible.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
+     * `keyValueOrEntryToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If a value
      * is provided, it will be used when creating the new node. If no value is provided, the new node
-     * @returns a node of type N or undefined.
+     * @returns a node of type NODE or undefined.
      */
-    exemplarToNode(keyOrNodeOrEntry, value) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value) {
         let node;
         if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
             return;
@@ -110,17 +110,13 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the RedBlackTreeNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the RedBlackTreeNode
      * class.
      */
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
     isRealNode(node) {
         if (node === this.Sentinel || node === undefined)
             return false;
@@ -129,7 +125,7 @@ class RedBlackTree extends bst_1.BST {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
+     * On average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -141,10 +137,10 @@ class RedBlackTree extends bst_1.BST {
      * entry.
      * @param {V} [value] - The `value` parameter represents the value associated with the key that is
      * being added to the binary search tree.
-     * @returns The method `add` returns either the newly added node (`N`) or `undefined`.
+     * @returns The method `add` returns either the newly added node (`NODE`) or `undefined`.
      */
     add(keyOrNodeOrEntry, value) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return false;
         newNode.left = this.Sentinel;
@@ -194,7 +190,6 @@ class RedBlackTree extends bst_1.BST {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     *  on average (where n is the number of nodes in the tree)
      */
     /**
      * Time Complexity: O(log n)
@@ -206,10 +201,10 @@ class RedBlackTree extends bst_1.BST {
      * that you want to use to identify the node that you want to delete from the binary tree. It can be
      * of any type that is returned by the callback function `C`. It can also be `null` or `undefined` if
      * you don't want to
-     * @param {C} callback - The `callback` parameter is a function that takes a node of type `N` and
+     * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` and
      * returns a value of type `ReturnType<C>`. It is used to determine if a node should be deleted based
      * on its identifier. The `callback` function is optional and defaults to `this._defaultOneParam
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
@@ -285,14 +280,14 @@ class RedBlackTree extends bst_1.BST {
      * node that matches the other criteria
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
-     * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * function should take a single parameter of type `NODE` (the type of the nodes in the binary tree) and
+     * @param {K | NODE | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of
      * iteration to be performed when searching for nodes in the binary tree. It is used in the
      * `getNodes` method, which is called within the `getNode` method.
-     * @returns a value of type `N`, `null`, or `undefined`.
+     * @returns a value of type `NODE`, `null`, or `undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
@@ -301,6 +296,14 @@ class RedBlackTree extends bst_1.BST {
         beginRoot = this.ensureNode(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    clear() {
+        this._root = this.Sentinel;
+        this._size = 0;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -325,14 +328,6 @@ class RedBlackTree extends bst_1.BST {
         }
         return y;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    clear() {
-        this._root = this.Sentinel;
-        this._size = 0;
-    }
     _setRoot(v) {
         if (v) {
             v.parent = undefined;
@@ -348,7 +343,7 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function performs a left rotation on a binary tree node.
-     * @param {RedBlackTreeNode} x - The parameter `x` is of type `N`, which likely represents a node in a binary tree.
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `NODE`, which likely represents a node in a binary tree.
      */
     _leftRotate(x) {
         if (x.right) {
@@ -406,6 +401,63 @@ class RedBlackTree extends bst_1.BST {
             x.parent = y;
         }
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
+     * red-black tree.
+     */
+    _fixInsert(k) {
+        let u;
+        while (k.parent && k.parent.color === 1) {
+            if (k.parent.parent && k.parent === k.parent.parent.right) {
+                u = k.parent.parent.left;
+                if (u && u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.left) {
+                        k = k.parent;
+                        this._rightRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._leftRotate(k.parent.parent);
+                }
+            }
+            else {
+                u = k.parent.parent.right;
+                if (u && u.color === 1) {
+                    u.color = types_1.RBTNColor.BLACK;
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    k = k.parent.parent;
+                }
+                else {
+                    if (k === k.parent.right) {
+                        k = k.parent;
+                        this._leftRotate(k);
+                    }
+                    k.parent.color = types_1.RBTNColor.BLACK;
+                    k.parent.parent.color = types_1.RBTNColor.RED;
+                    this._rightRotate(k.parent.parent);
+                }
+            }
+            if (k === this.root) {
+                break;
+            }
+        }
+        this.root.color = types_1.RBTNColor.BLACK;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -505,68 +557,11 @@ class RedBlackTree extends bst_1.BST {
         }
         v.parent = u.parent;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
-     * red-black tree.
-     */
-    _fixInsert(k) {
-        let u;
-        while (k.parent && k.parent.color === 1) {
-            if (k.parent.parent && k.parent === k.parent.parent.right) {
-                u = k.parent.parent.left;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    k = k.parent.parent;
-                }
-                else {
-                    if (k === k.parent.left) {
-                        k = k.parent;
-                        this._rightRotate(k);
-                    }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    this._leftRotate(k.parent.parent);
-                }
-            }
-            else {
-                u = k.parent.parent.right;
-                if (u && u.color === 1) {
-                    u.color = types_1.RBTNColor.BLACK;
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    k = k.parent.parent;
-                }
-                else {
-                    if (k === k.parent.right) {
-                        k = k.parent;
-                        this._leftRotate(k);
-                    }
-                    k.parent.color = types_1.RBTNColor.BLACK;
-                    k.parent.parent.color = types_1.RBTNColor.RED;
-                    this._rightRotate(k.parent.parent);
-                }
-            }
-            if (k === this.root) {
-                break;
-            }
-        }
-        this.root.color = types_1.RBTNColor.BLACK;
-    }
     /**
      * The function replaces an old node with a new node while preserving the color of the old node.
-     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
-     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
-     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `NODE`, which is the type of the nodes in the data structure.
+     * @param {NODE} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
      * data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, passing in the `oldNode` and `newNode` as arguments.