min-heap-typed 1.42.6 → 1.42.8

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

@@ -10,9 +10,9 @@ import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-    parent: N | undefined;
+    parent?: N;
     constructor(key: BTNKey, value?: V);
-    protected _left: N | undefined;
+    protected _left?: N;
     /**
      * Get the left child node.
      */
@@ -22,7 +22,7 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
      * @param {N | undefined} v - The left child node.
      */
     set left(v: N | undefined);
-    protected _right: N | undefined;
+    protected _right?: N;
     /**
      * Get the right child node.
      */
@@ -41,7 +41,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * binary search tree.
      */
     constructor(options?: BSTOptions);
-    protected _root: N | undefined;
+    protected _root?: N;
     /**
      * Get the root node of the binary tree.
      */
@@ -79,7 +79,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * It can have two possible values:
      * @returns The `addMany` function returns an array of `N`, `undefined`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | undefined)[] | (N | undefined)[], data?: V[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
      * than, the key of the leftmost node if the comparison result is greater than, and the key of the
@@ -95,7 +95,29 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot?: N | undefined, iterationType?: IterationType): BTNKey;
+    lastKey(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): BTNKey;
+    /**
+     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+     * either recursive or iterative methods.
+     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to find the node with the matching key value.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when searching for a node in the binary tree. It can have two possible
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    /**
+     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNotKey(key: BTNKey | N | undefined, iterationType?: IterationType): N | undefined;
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
@@ -104,7 +126,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, which is
+     * included in the result. The default value for `callback` is `this._defaultOneParamCallback`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -117,7 +139,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: N | undefined, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): N[];
     /**
      * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
      * nodes that have a key value lesser or greater than a target key value.

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

@@ -54,7 +54,6 @@ class BST extends binary_tree_1.BinaryTree {
      */
     constructor(options) {
         super(options);
-        this._root = undefined;
         this._comparator = (a, b) => a - b;
         this._root = undefined;
         if (options !== undefined) {
@@ -92,9 +91,6 @@ class BST extends binary_tree_1.BinaryTree {
      * was not added or if the parameters were invalid, it returns undefined or undefined.
      */
     add(keyOrNode, value) {
-        if (keyOrNode === 8) {
-            debugger;
-        }
         if (keyOrNode === null)
             return undefined;
         // TODO support node as a parameter
@@ -103,7 +99,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (keyOrNode instanceof BSTNode) {
             newNode = keyOrNode;
         }
-        else if (typeof keyOrNode === 'number') {
+        else if (this.isNodeKey(keyOrNode)) {
             newNode = this.createNode(keyOrNode, value);
         }
         else {
@@ -186,32 +182,32 @@ class BST extends binary_tree_1.BinaryTree {
      */
     addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
-        function hasNoNull(arr) {
+        function hasNoUndefined(arr) {
             return arr.indexOf(undefined) === -1;
         }
-        if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
+        if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
             return super.addMany(keysOrNodes, data).map(n => n !== null && n !== void 0 ? n : undefined);
         }
         const inserted = [];
         const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
         let sorted = [];
-        function isNodeOrNullTuple(arr) {
+        function _isNodeOrUndefinedTuple(arr) {
             for (const [keyOrNode] of arr)
                 if (keyOrNode instanceof BSTNode)
                     return true;
             return false;
         }
-        function isBinaryTreeKeyOrNullTuple(arr) {
+        const _isBinaryTreeKeyOrNullTuple = (arr) => {
             for (const [keyOrNode] of arr)
-                if (typeof keyOrNode === 'number')
+                if (this.isNodeKey(keyOrNode))
                     return true;
             return false;
-        }
+        };
         let sortedKeysOrNodes = [], sortedData = [];
-        if (isNodeOrNullTuple(combinedArr)) {
+        if (_isNodeOrUndefinedTuple(combinedArr)) {
             sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
         }
-        else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
+        else if (_isBinaryTreeKeyOrNullTuple(combinedArr)) {
             sorted = combinedArr.sort((a, b) => a[0] - b[0]);
         }
         else {
@@ -219,16 +215,16 @@ class BST extends binary_tree_1.BinaryTree {
         }
         sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
         sortedData = sorted.map(([, value]) => value);
-        const recursive = (arr, data) => {
+        const _dfs = (arr, data) => {
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
             const newNode = this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
             inserted.push(newNode);
-            recursive(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
-            recursive(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
+            _dfs(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
+            _dfs(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
         };
-        const iterative = () => {
+        const _iterate = () => {
             const n = sorted.length;
             const stack = [[0, n - 1]];
             while (stack.length > 0) {
@@ -246,10 +242,10 @@ class BST extends binary_tree_1.BinaryTree {
             }
         };
         if (iterationType === types_1.IterationType.RECURSIVE) {
-            recursive(sortedKeysOrNodes, sortedData);
+            _dfs(sortedKeysOrNodes, sortedData);
         }
         else {
-            iterative();
+            _iterate();
         }
         return inserted;
     }
@@ -277,6 +273,60 @@ class BST extends binary_tree_1.BinaryTree {
         else
             return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
     }
+    /**
+     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+     * either recursive or iterative methods.
+     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to find the node with the matching key value.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when searching for a node in the binary tree. It can have two possible
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+        if (!this.root)
+            return undefined;
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const _dfs = (cur) => {
+                if (cur.key === key)
+                    return cur;
+                if (!cur.left && !cur.right)
+                    return;
+                if (this._compare(cur.key, key) === types_1.CP.gt && cur.left)
+                    return _dfs(cur.left);
+                if (this._compare(cur.key, key) === types_1.CP.lt && cur.right)
+                    return _dfs(cur.right);
+            };
+            return _dfs(this.root);
+        }
+        else {
+            const queue = new queue_1.Queue([this.root]);
+            while (queue.size > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    if (this._compare(cur.key, key) === types_1.CP.eq)
+                        return cur;
+                    if (this._compare(cur.key, key) === types_1.CP.gt)
+                        cur.left && queue.push(cur.left);
+                    if (this._compare(cur.key, key) === types_1.CP.lt)
+                        cur.right && queue.push(cur.right);
+                }
+            }
+        }
+    }
+    /**
+     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+        return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+    }
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
      * using either recursive or iterative traversal.
@@ -285,7 +335,7 @@ class BST extends binary_tree_1.BinaryTree {
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, which is
+     * included in the result. The default value for `callback` is `this._defaultOneParamCallback`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -298,7 +348,8 @@ class BST extends binary_tree_1.BinaryTree {
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+        beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
@@ -313,7 +364,7 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!cur.left && !cur.right)
                     return;
                 // TODO potential bug
-                if (callback === this.defaultOneParamCallback) {
+                if (callback === this._defaultOneParamCallback) {
                     if (this._compare(cur.key, identifier) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
                     if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -338,7 +389,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === this.defaultOneParamCallback) {
+                    if (callback === this._defaultOneParamCallback) {
                         if (this._compare(cur.key, identifier) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
                         if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -371,16 +422,14 @@ class BST extends binary_tree_1.BinaryTree {
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    lesserOrGreaterTraverse(callback = this.defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
-        var _a;
-        if (typeof targetNode === 'number')
-            targetNode = (_a = this.getNode(targetNode)) !== null && _a !== void 0 ? _a : undefined;
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+        targetNode = this.ensureNotKey(targetNode);
         const ans = [];
         if (!targetNode)
             return ans;
-        const targetKey = targetNode.key;
         if (!this.root)
             return ans;
+        const targetKey = targetNode.key;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);

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 { BinaryTreeDeletedResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RedBlackTreeNodeNested, RBTreeOptions } from '../../types';
 import { BST, BSTNode } from "./bst";
 import { IBinaryTree } from "../../interfaces";
-export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
+export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
     color: RBTNColor;
     constructor(key: BTNKey, value?: V, color?: RBTNColor);
 }
@@ -19,74 +19,81 @@ export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNode
  * 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<V = any, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     constructor(options?: RBTreeOptions);
     protected _root: N;
     get root(): N;
     protected _size: number;
     get size(): number;
     NIL: N;
+    /**
+     * The `add` function adds a new node to a Red-Black Tree data structure.
+     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
+     * following types:
+     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+     * key in the node being added to the Red-Black Tree.
+     * @returns The method returns either a node (`N`) or `undefined`.
+     */
     add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
     createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BinaryTreeDeletedResult<N>[];
-    isNode(node: N | undefined): node is N;
+    /**
+     * The `delete` function removes a node from a binary tree based on a given identifier and updates
+     * the tree accordingly.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * 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
+     * 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 `BiTreeDeleteResult<N>`.
+     */
+    delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null | undefined, callback?: C): BiTreeDeleteResult<N>[];
+    isRealNode(node: N | undefined): node is N;
     getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, 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;
-    /**
-     * The function returns the leftmost node in a red-black tree.
-     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
-     * a Red-Black Tree.
-     * @returns The leftmost node in the given RBTreeNode.
-     */
-    getLeftMost(node?: N): N;
-    /**
-     * The function returns the rightmost node in a red-black tree.
-     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
-     * @returns the rightmost node in a red-black tree.
-     */
-    getRightMost(node: N): N;
     /**
      * The function returns the successor of a given node in a red-black tree.
-     * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RBTreeNode.
+     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
+     * @returns the successor of the given RedBlackTreeNode.
      */
     getSuccessor(x: N): N | undefined;
     /**
      * The function returns the predecessor of a given node in a red-black tree.
-     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * @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 RBTreeNode 'x'.
+     * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x: N): N;
     clear(): void;
     protected _setRoot(v: N): void;
     /**
      * The function performs a left rotation on a red-black tree node.
-     * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
+     * @param {RedBlackTreeNode} x - The parameter `x` is a RedBlackTreeNode object.
      */
     protected _leftRotate(x: N): void;
     /**
      * The function performs a right rotation on a red-black tree node.
-     * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
+     * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
      * rotated.
      */
     protected _rightRotate(x: N): void;
     /**
      * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
-     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
      * red-black tree.
      */
     protected _fixDelete(x: N): void;
     /**
      * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-     * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
-     * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
+     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
+     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
      */
     protected _rbTransplant(u: N, v: N): void;
     /**
      * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
      * red-black tree.
      */
     protected _fixInsert(k: N): void;

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

@@ -7,17 +7,17 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedBlackTree = exports.RBTreeNode = void 0;
+exports.RedBlackTree = exports.RedBlackTreeNode = void 0;
 const types_1 = require("../../types");
 const bst_1 = require("./bst");
 const binary_tree_1 = require("./binary-tree");
-class RBTreeNode extends bst_1.BSTNode {
+class RedBlackTreeNode extends bst_1.BSTNode {
     constructor(key, value, color = types_1.RBTNColor.BLACK) {
         super(key, value);
         this.color = color;
     }
 }
-exports.RBTreeNode = RBTreeNode;
+exports.RedBlackTreeNode = RedBlackTreeNode;
 /**
  * 1. Each node is either red or black.
  * 2. The root node is always black.
@@ -29,7 +29,7 @@ class RedBlackTree extends bst_1.BST {
     constructor(options) {
         super(options);
         this._size = 0;
-        this.NIL = new RBTreeNode(NaN);
+        this.NIL = new RedBlackTreeNode(NaN);
         this._root = this.NIL;
     }
     get root() {
@@ -38,12 +38,20 @@ class RedBlackTree extends bst_1.BST {
     get size() {
         return this._size;
     }
+    /**
+     * The `add` function adds a new node to a Red-Black Tree data structure.
+     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
+     * following types:
+     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
+     * key in the node being added to the Red-Black Tree.
+     * @returns The method returns either a node (`N`) or `undefined`.
+     */
     add(keyOrNode, value) {
         let node;
-        if (typeof keyOrNode === 'number') {
+        if (this.isNodeKey(keyOrNode)) {
             node = this.createNode(keyOrNode, value, types_1.RBTNColor.RED);
         }
-        else if (keyOrNode instanceof RBTreeNode) {
+        else if (keyOrNode instanceof RedBlackTreeNode) {
             node = keyOrNode;
         }
         else if (keyOrNode === null) {
@@ -91,9 +99,21 @@ class RedBlackTree extends bst_1.BST {
         this._size++;
     }
     createNode(key, value, color = types_1.RBTNColor.BLACK) {
-        return new RBTreeNode(key, value, color);
+        return new RedBlackTreeNode(key, value, color);
     }
-    delete(identifier, callback = this.defaultOneParamCallback) {
+    /**
+     * The `delete` function removes a node from a binary tree based on a given identifier and updates
+     * the tree accordingly.
+     * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
+     * 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
+     * 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 `BiTreeDeleteResult<N>`.
+     */
+    delete(identifier, callback = this._defaultOneParamCallback) {
         const ans = [];
         if (identifier === null)
             return ans;
@@ -151,7 +171,7 @@ class RedBlackTree extends bst_1.BST {
         // TODO
         return ans;
     }
-    isNode(node) {
+    isRealNode(node) {
         return node !== this.NIL && node !== undefined;
     }
     /**
@@ -162,50 +182,29 @@ class RedBlackTree extends bst_1.BST {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`this.defaultOneParamCallback`) is used if no callback function is
+     * (`this._defaultOneParamCallback`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    getNode(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof binary_tree_1.BinaryTreeNode)
             callback = (node => node);
+        beginRoot = this.ensureNotKey(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
-    /**
-     * The function returns the leftmost node in a red-black tree.
-     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
-     * a Red-Black Tree.
-     * @returns The leftmost node in the given RBTreeNode.
-     */
-    getLeftMost(node = this.root) {
-        while (node.left !== undefined && node.left !== this.NIL) {
-            node = node.left;
-        }
-        return node;
-    }
-    /**
-     * The function returns the rightmost node in a red-black tree.
-     * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
-     * @returns the rightmost node in a red-black tree.
-     */
-    getRightMost(node) {
-        while (node.right !== undefined && node.right !== this.NIL) {
-            node = node.right;
-        }
-        return node;
-    }
     /**
      * The function returns the successor of a given node in a red-black tree.
-     * @param {RBTreeNode} x - RBTreeNode - The node for which we want to find the successor.
-     * @returns the successor of the given RBTreeNode.
+     * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
+     * @returns the successor of the given RedBlackTreeNode.
      */
     getSuccessor(x) {
+        var _a;
         if (x.right !== this.NIL) {
-            return this.getLeftMost(x.right);
+            return (_a = this.getLeftMost(x.right)) !== null && _a !== void 0 ? _a : undefined;
         }
         let y = x.parent;
         while (y !== this.NIL && y !== undefined && x === y.right) {
@@ -216,9 +215,9 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function returns the predecessor of a given node in a red-black tree.
-     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * @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 RBTreeNode 'x'.
+     * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
         if (x.left !== this.NIL) {
@@ -243,7 +242,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function performs a left rotation on a red-black tree node.
-     * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
+     * @param {RedBlackTreeNode} x - The parameter `x` is a RedBlackTreeNode object.
      */
     _leftRotate(x) {
         if (x.right) {
@@ -269,7 +268,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function performs a right rotation on a red-black tree node.
-     * @param {RBTreeNode} x - x is a RBTreeNode, which represents the node that needs to be right
+     * @param {RedBlackTreeNode} x - x is a RedBlackTreeNode, which represents the node that needs to be right
      * rotated.
      */
     _rightRotate(x) {
@@ -296,7 +295,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The _fixDelete function is used to rebalance the Red-Black Tree after a node deletion.
-     * @param {RBTreeNode} x - The parameter `x` is of type `RBTreeNode`, which represents a node in a
+     * @param {RedBlackTreeNode} x - The parameter `x` is of type `RedBlackTreeNode`, which represents a node in a
      * red-black tree.
      */
     _fixDelete(x) {
@@ -365,8 +364,8 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The function `_rbTransplant` replaces one node in a red-black tree with another node.
-     * @param {RBTreeNode} u - The parameter "u" represents a RBTreeNode object.
-     * @param {RBTreeNode} v - The parameter "v" is a RBTreeNode object.
+     * @param {RedBlackTreeNode} u - The parameter "u" represents a RedBlackTreeNode object.
+     * @param {RedBlackTreeNode} v - The parameter "v" is a RedBlackTreeNode object.
      */
     _rbTransplant(u, v) {
         if (u.parent === undefined) {
@@ -382,7 +381,7 @@ class RedBlackTree extends bst_1.BST {
     }
     /**
      * The `_fixInsert` function is used to fix the red-black tree after an insertion operation.
-     * @param {RBTreeNode} k - The parameter `k` is a RBTreeNode object, which represents a node in a
+     * @param {RedBlackTreeNode} k - The parameter `k` is a RedBlackTreeNode object, which represents a node in a
      * red-black tree.
      */
     _fixInsert(k) {