directed-graph-typed 1.51.1 → 1.51.3

package/README.md

@@ -2,7 +2,7 @@
 ![GitHub top language](https://img.shields.io/github/languages/top/zrwusa/data-structure-typed)
 ![npm](https://img.shields.io/npm/dw/directed-graph-typed)
 ![eslint](https://aleen42.github.io/badges/src/eslint.svg)
-![npm package minimized gzipped size (select exports)](https://img.shields.io/bundlejs/size/directed-graph-typed)
+![npm bundle size](https://img.shields.io/bundlephobia/minzip/directed-graph-typed)
 ![npm bundle size](https://img.shields.io/bundlephobia/min/directed-graph-typed)
 ![npm](https://img.shields.io/npm/v/directed-graph-typed)
 

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

@@ -97,6 +97,12 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @returns The size of the object, which is a number.
      */
     get size(): number;
+    protected _NIL: NODE;
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL(): NODE;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -140,19 +146,18 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | null | undefined;
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class NODE.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -167,11 +172,12 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      */
     isNIL(node: KeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
+    isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V>;
     /**
      * Time Complexity O(n)
      * Space Complexity O(1)

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

@@ -107,6 +107,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = 'ITERATIVE';
         this._extractor = (key) => (typeof key === 'number' ? key : Number(key));
+        this._NIL = new BinaryTreeNode(NaN);
         this._DEFAULT_CALLBACK = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
@@ -141,6 +142,13 @@ class BinaryTree extends base_1.IterableEntryBase {
     get size() {
         return this._size;
     }
+    /**
+     * The function returns the value of the _NIL property.
+     * @returns The method is returning the value of the `_NIL` property.
+     */
+    get NIL() {
+        return this._NIL;
+    }
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {K} key - The key for the new node.
@@ -235,6 +243,14 @@ class BinaryTree extends base_1.IterableEntryBase {
             return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
     }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+        return this.isRealNode(node) || node === null;
+    }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
@@ -243,15 +259,6 @@ class BinaryTree extends base_1.IterableEntryBase {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof BinaryTreeNode;
     }
-    /**
-     * The function checks if a given value is an entry in a binary tree node.
-     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-     * two type parameters V and NODE, representing the value and node type respectively.
-     * @returns a boolean value.
-     */
-    isEntry(keyOrNodeOrEntry) {
-        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-    }
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -259,7 +266,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+        if (!this.isNode(node))
+            return false;
+        return node !== this.NIL;
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -267,15 +276,16 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isNIL(node) {
-        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+        return node === this.NIL;
     }
     /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and NODE, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isNodeOrNull(node) {
-        return this.isRealNode(node) || node === null;
+    isEntry(keyOrNodeOrEntry) {
+        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
     }
     /**
      * Time Complexity O(n)
@@ -502,10 +512,10 @@ class BinaryTree extends base_1.IterableEntryBase {
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                cur.left && dfs(cur.left);
-                cur.right && dfs(cur.right);
+                this.isRealNode(cur.left) && dfs(cur.left);
+                this.isRealNode(cur.right) && dfs(cur.right);
             };
             dfs(beginRoot);
         }
@@ -513,14 +523,14 @@ class BinaryTree extends base_1.IterableEntryBase {
             const stack = [beginRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                if (cur) {
+                if (this.isRealNode(cur)) {
                     if (callback(cur) === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
-                    cur.left && stack.push(cur.left);
-                    cur.right && stack.push(cur.right);
+                    this.isRealNode(cur.left) && stack.push(cur.left);
+                    this.isRealNode(cur.right) && stack.push(cur.right);
                 }
             }
         }
@@ -553,8 +563,6 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
@@ -632,8 +640,6 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b;
-        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-            callback = (node => node);
         return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
     /**

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
+import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, NODE> {
@@ -209,6 +209,32 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns The method returns an array of nodes (`NODE[]`).
      */
     getNodes<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE[];
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+     * that you want to search for in the binary search tree. It can be of any type that is compatible
+     * with the type of nodes in the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+     * function should take a node as its parameter and return a value that can be compared to the
+     * `identifier` parameter.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+     * using the `ensureNode` method. If it is not provided, the `root`
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+     * its default value is taken from the `iterationType` property of the class.
+     * @returns The method is returning a value of type `NODE | null | undefined`.
+     */
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | undefined;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

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

@@ -482,6 +482,35 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+     * callback function.
+     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+     * that you want to search for in the binary search tree. It can be of any type that is compatible
+     * with the type of nodes in the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+     * function should take a node as its parameter and return a value that can be compared to the
+     * `identifier` parameter.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+     * using the `ensureNode` method. If it is not provided, the `root`
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+     * its default value is taken from the `iterationType` property of the class.
+     * @returns The method is returning a value of type `NODE | null | undefined`.
+     */
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+        var _a;
+        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -39,12 +39,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * should compare keys and
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
-    protected _SENTINEL: NODE;
-    /**
-     * The function returns the value of the _SENTINEL property.
-     * @returns The method is returning the value of the `_SENTINEL` property.
-     */
-    get SENTINEL(): NODE;
     protected _root: NODE | undefined;
     /**
      * The function returns the root node of a tree or undefined if there is no root.
@@ -101,46 +95,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns {boolean} - `true` if the object is a Red-Black Tree node, `false` otherwise.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given node is a real node in a Red-Black Tree.
-     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-     * it can either be of type `NODE` or `undefined`.
-     * @returns a boolean value.
-     */
-    isRealNode(node: NODE | undefined): node is NODE;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-     * that you want to search for in the binary search tree. It can be of any type that is compatible
-     * with the type of nodes in the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-     * function should take a node as its parameter and return a value that can be compared to the
-     * `identifier` parameter.
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-     * using the `ensureNode` method. If it is not provided, the `root`
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-     * its default value is taken from the `iterationType` property of the class.
-     * @returns The method is returning a value of type `NODE | null | undefined`.
-     */
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -47,19 +47,11 @@ class RedBlackTree extends bst_1.BST {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this._SENTINEL = new RedBlackTreeNode(NaN);
-        this._root = this.SENTINEL;
+        this._root = this.NIL;
         if (keysOrNodesOrEntries) {
             this.addMany(keysOrNodesOrEntries);
         }
     }
-    /**
-     * The function returns the value of the _SENTINEL property.
-     * @returns The method is returning the value of the `_SENTINEL` property.
-     */
-    get SENTINEL() {
-        return this._SENTINEL;
-    }
     /**
      * The function returns the root node of a tree or undefined if there is no root.
      * @returns The root node of the tree structure, or undefined if there is no root node.
@@ -147,53 +139,6 @@ class RedBlackTree extends bst_1.BST {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof RedBlackTreeNode;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a given node is a real node in a Red-Black Tree.
-     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-     * it can either be of type `NODE` or `undefined`.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-        if (node === this.SENTINEL || node === undefined)
-            return false;
-        return node instanceof RedBlackTreeNode;
-    }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-     * callback function.
-     * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-     * that you want to search for in the binary search tree. It can be of any type that is compatible
-     * with the type of nodes in the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-     * function should take a node as its parameter and return a value that can be compared to the
-     * `identifier` parameter.
-     * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-     * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-     * using the `ensureNode` method. If it is not provided, the `root`
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-     * its default value is taken from the `iterationType` property of the class.
-     * @returns The method is returning a value of type `NODE | null | undefined`.
-     */
-    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
-        return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -207,7 +152,7 @@ class RedBlackTree extends bst_1.BST {
      */
     clear() {
         super.clear();
-        this._root = this.SENTINEL;
+        this._root = this.NIL;
     }
     /**
      * Time Complexity: O(log n)
@@ -369,10 +314,10 @@ class RedBlackTree extends bst_1.BST {
         while (this.isRealNode(current)) {
             parent = current;
             if (node.key < current.key) {
-                current = (_a = current.left) !== null && _a !== void 0 ? _a : this.SENTINEL;
+                current = (_a = current.left) !== null && _a !== void 0 ? _a : this.NIL;
             }
             else if (node.key > current.key) {
-                current = (_b = current.right) !== null && _b !== void 0 ? _b : this.SENTINEL;
+                current = (_b = current.right) !== null && _b !== void 0 ? _b : this.NIL;
             }
             else {
                 this._replaceNode(current, node);
@@ -389,8 +334,8 @@ class RedBlackTree extends bst_1.BST {
         else {
             parent.right = node;
         }
-        node.left = this.SENTINEL;
-        node.right = this.SENTINEL;
+        node.left = this.NIL;
+        node.right = this.NIL;
         node.color = 'RED';
         this._insertFixup(node);
         return 'CREATED';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directed-graph-typed",
-  "version": "1.51.1",
+  "version": "1.51.3",
   "description": "Directed Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -147,6 +147,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.51.0"
+    "data-structure-typed": "^1.51.3"
   }
 }

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

@@ -191,6 +191,16 @@ export class BinaryTree<
     return this._size;
   }
 
+  protected _NIL: NODE = new BinaryTreeNode<K, V>(NaN as K) as unknown as NODE;
+
+  /**
+   * The function returns the value of the _NIL property.
+   * @returns The method is returning the value of the `_NIL` property.
+   */
+  get NIL(): NODE {
+    return this._NIL;
+  }
+
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {K} key - The key for the new node.
@@ -281,6 +291,15 @@ export class BinaryTree<
     }
   }
 
+  /**
+   * The function checks if a given node is a real node or null.
+   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * @returns a boolean value.
+   */
+  isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null {
+    return this.isRealNode(node) || node === null;
+  }
+
   /**
    * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
@@ -290,16 +309,6 @@ export class BinaryTree<
     return keyOrNodeOrEntry instanceof BinaryTreeNode;
   }
 
-  /**
-   * The function checks if a given value is an entry in a binary tree node.
-   * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
-   * two type parameters V and NODE, representing the value and node type respectively.
-   * @returns a boolean value.
-   */
-  isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V> {
-    return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
-  }
-
   /**
    * The function checks if a given node is a real node by verifying if it is an instance of
    * BinaryTreeNode and its key is not NaN.
@@ -307,7 +316,8 @@ export class BinaryTree<
    * @returns a boolean value.
    */
   isRealNode(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE {
-    return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+    if (!this.isNode(node)) return false;
+    return node !== this.NIL;
   }
 
   /**
@@ -316,16 +326,17 @@ export class BinaryTree<
    * @returns a boolean value.
    */
   isNIL(node: KeyOrNodeOrEntry<K, V, NODE>) {
-    return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+    return node === this.NIL;
   }
 
   /**
-   * The function checks if a given node is a real node or null.
-   * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+   * The function checks if a given value is an entry in a binary tree node.
+   * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,NODE> - A generic type representing a node in a binary tree. It has
+   * two type parameters V and NODE, representing the value and node type respectively.
    * @returns a boolean value.
    */
-  isNodeOrNull(node: KeyOrNodeOrEntry<K, V, NODE>): node is NODE | null {
-    return this.isRealNode(node) || node === null;
+  isEntry(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is BTNEntry<K, V> {
+    return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
   }
 
   /**
@@ -612,9 +623,9 @@ export class BinaryTree<
           ans.push(cur);
           if (onlyOne) return;
         }
-        if (!cur.left && !cur.right) return;
-        cur.left && dfs(cur.left);
-        cur.right && dfs(cur.right);
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
+        this.isRealNode(cur.left) && dfs(cur.left);
+        this.isRealNode(cur.right) && dfs(cur.right);
       };
 
       dfs(beginRoot);
@@ -622,13 +633,13 @@ export class BinaryTree<
       const stack = [beginRoot];
       while (stack.length > 0) {
         const cur = stack.pop();
-        if (cur) {
+        if (this.isRealNode(cur)) {
           if (callback(cur) === identifier) {
             ans.push(cur);
             if (onlyOne) return ans;
           }
-          cur.left && stack.push(cur.left);
-          cur.right && stack.push(cur.right);
+          this.isRealNode(cur.left) && stack.push(cur.left);
+          this.isRealNode(cur.right) && stack.push(cur.right);
         }
       }
     }
@@ -689,9 +700,6 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
-
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
@@ -793,9 +801,6 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
-
     return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
   }
 

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

@@ -13,7 +13,7 @@ import type {
   BTNodePureExemplar,
   KeyOrNodeOrEntry
 } from '../../types';
-import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
+import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
@@ -543,6 +543,41 @@ export class BST<
     return ans;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
+   * callback function.
+   * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
+   * that you want to search for in the binary search tree. It can be of any type that is compatible
+   * with the type of nodes in the tree.
+   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+   * the tree. It is used to determine whether a node matches the given identifier. The `callback`
+   * function should take a node as its parameter and return a value that can be compared to the
+   * `identifier` parameter.
+   * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
+   * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
+   * using the `ensureNode` method. If it is not provided, the `root`
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed when searching for nodes in the binary search tree. It is an optional parameter and
+   * its default value is taken from the `iterationType` property of the class.
+   * @returns The method is returning a value of type `NODE | null | undefined`.
+   */
+  override getNode<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | undefined,
+    callback: C = this._DEFAULT_CALLBACK as C,
+    beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): NODE | undefined {
+    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)

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

@@ -1,8 +1,6 @@
 import type {
   BinaryTreeDeleteResult,
-  BSTNKeyOrNode,
   BTNCallback,
-  IterationType,
   KeyOrNodeOrEntry,
   RBTreeOptions,
   RedBlackTreeNested,
@@ -73,23 +71,13 @@ export class RedBlackTree<
   constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: RBTreeOptions<K>) {
     super([], options);
 
-    this._root = this.SENTINEL;
+    this._root = this.NIL;
 
     if (keysOrNodesOrEntries) {
       this.addMany(keysOrNodesOrEntries);
     }
   }
 
-  protected _SENTINEL: NODE = new RedBlackTreeNode<K, V>(NaN as K) as unknown as NODE;
-
-  /**
-   * The function returns the value of the _SENTINEL property.
-   * @returns The method is returning the value of the `_SENTINEL` property.
-   */
-  get SENTINEL(): NODE {
-    return this._SENTINEL;
-  }
-
   protected override _root: NODE | undefined;
 
   /**
@@ -184,60 +172,6 @@ export class RedBlackTree<
     return keyOrNodeOrEntry instanceof RedBlackTreeNode;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given node is a real node in a Red-Black Tree.
-   * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
-   * it can either be of type `NODE` or `undefined`.
-   * @returns a boolean value.
-   */
-  override isRealNode(node: NODE | undefined): node is NODE {
-    if (node === this.SENTINEL || node === undefined) return false;
-    return node instanceof RedBlackTreeNode;
-  }
-
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   *
-   * The `getNode` function retrieves a node from a Red-Black Tree based on the provided identifier and
-   * callback function.
-   * @param {ReturnType<C> | undefined} identifier - The `identifier` parameter is the value or key
-   * that you want to search for in the binary search tree. It can be of any type that is compatible
-   * with the type of nodes in the tree.
-   * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-   * the tree. It is used to determine whether a node matches the given identifier. The `callback`
-   * function should take a node as its parameter and return a value that can be compared to the
-   * `identifier` parameter.
-   * @param beginRoot - The `beginRoot` parameter is the starting point for the search in the binary
-   * search tree. It can be either a key or a node. If it is a key, it will be converted to a node
-   * using the `ensureNode` method. If it is not provided, the `root`
-   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-   * be performed when searching for nodes in the binary search tree. It is an optional parameter and
-   * its default value is taken from the `iterationType` property of the class.
-   * @returns The method is returning a value of type `NODE | null | undefined`.
-   */
-  override getNode<C extends BTNCallback<NODE>>(
-    identifier: ReturnType<C> | undefined,
-    callback: C = this._DEFAULT_CALLBACK as C,
-    beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
-    iterationType: IterationType = this.iterationType
-  ): NODE | null | undefined {
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -252,7 +186,7 @@ export class RedBlackTree<
    */
   override clear() {
     super.clear();
-    this._root = this.SENTINEL;
+    this._root = this.NIL;
   }
 
   /**
@@ -430,9 +364,9 @@ export class RedBlackTree<
     while (this.isRealNode(current)) {
       parent = current;
       if (node.key < current.key) {
-        current = current.left ?? this.SENTINEL;
+        current = current.left ?? this.NIL;
       } else if (node.key > current.key) {
-        current = current.right ?? this.SENTINEL;
+        current = current.right ?? this.NIL;
       } else {
         this._replaceNode(current, node);
         return 'UPDATED';
@@ -449,8 +383,8 @@ export class RedBlackTree<
       parent.right = node;
     }
 
-    node.left = this.SENTINEL;
-    node.right = this.SENTINEL;
+    node.left = this.NIL;
+    node.right = this.NIL;
     node.color = 'RED';
 
     this._insertFixup(node);