min-heap-typed 1.48.9 → 1.49.0

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

@@ -7,7 +7,7 @@
  */
 import { BST, BSTNode } from './bst';
 import type { AVLTreeNested, AVLTreeNodeNested, AVLTreeOptions, BiTreeDeleteResult, BSTNodeKeyOrNode, BTNodeExemplar } from '../../types';
-import { BTNCallback } from '../../types';
+import { BTNCallback, BTNodeKeyOrNode } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     height: number;
@@ -58,6 +58,13 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
      */
     isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -71,6 +71,15 @@ class AVLTree extends bst_1.BST {
     isNode(exemplar) {
         return exemplar instanceof AVLTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof AVLTreeNode);
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -385,21 +385,21 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isRealNode(node: any): node is N;
+    isRealNode(node: BTNodeExemplar<K, V, N>): node is N;
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
      * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
      * @returns a boolean value.
      */
-    isNIL(node: any): boolean;
+    isNIL(node: BTNodeExemplar<K, V, N>): 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.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: any): node is N | null;
+    isNodeOrNull(node: BTNodeExemplar<K, V, N>): node is N | null;
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
@@ -423,8 +423,17 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
     listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
     listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: BTNodeKeyOrNode<K, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
+     * 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 tree.
+     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
     getPredecessor(node: N): N;
     /**

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

@@ -980,7 +980,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isRealNode(node) {
-        return node instanceof BinaryTreeNode && node.key.toString() !== 'NaN';
+        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
     }
     /**
      * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
@@ -988,7 +988,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns a boolean value.
      */
     isNIL(node) {
-        return node instanceof BinaryTreeNode && node.key.toString() === 'NaN';
+        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -999,7 +999,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         return this.isRealNode(node) || node === null;
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a number.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
      * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
      * data type.
      * @returns a boolean value indicating whether the potentialKey is of type number or not.
@@ -1280,19 +1280,23 @@ class BinaryTree extends base_1.IterableEntryBase {
         return levelsNodes;
     }
     /**
-     * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-     * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`.
-     * @returns The function `getPredecessor` returns a value of type `N | undefined`.
+     * 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 tree.
+     * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+     * tree.
+     * @returns the predecessor of the given 'node'.
      */
     getPredecessor(node) {
-        node = this.ensureNode(node);
-        if (!this.isRealNode(node))
-            return undefined;
-        if (node.left) {
+        if (this.isRealNode(node.left)) {
             let predecessor = node.left;
             while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
-                if (predecessor) {
+                if (this.isRealNode(predecessor)) {
                     predecessor = predecessor.right;
                 }
             }
@@ -1310,13 +1314,13 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     getSuccessor(x) {
         x = this.ensureNode(x);
-        if (!x)
+        if (!this.isRealNode(x))
             return undefined;
-        if (x.right) {
+        if (this.isRealNode(x.right)) {
             return this.getLeftMost(x.right);
         }
         let y = x.parent;
-        while (y && y && x === y.right) {
+        while (this.isRealNode(y) && x === y.right) {
             x = y;
             y = y.parent;
         }

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
-import { BSTVariant, CP, IterationType } from '../../types';
+import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
@@ -169,6 +169,13 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -387,6 +387,15 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BSTNode);
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, BTNodeKeyOrNode, IterationType, 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> {
@@ -65,6 +65,13 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * class.
      */
     isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -120,24 +127,11 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
     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;
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @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;
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.

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

@@ -85,6 +85,15 @@ class RedBlackTree extends bst_1.BST {
     isNode(exemplar) {
         return exemplar instanceof RedBlackTreeNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof RedBlackTreeNode);
+    }
     /**
      * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -263,7 +272,9 @@ class RedBlackTree extends bst_1.BST {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-        return node !== this.Sentinel && node !== undefined;
+        if (node === this.Sentinel || node === undefined)
+            return false;
+        return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -298,35 +309,11 @@ class RedBlackTree extends bst_1.BST {
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
-     *
-     * The function returns the successor of a given node in a red-black tree.
-     * @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.Sentinel) {
-            return (_a = this.getLeftMost(x.right)) !== null && _a !== void 0 ? _a : undefined;
-        }
-        let y = x.parent;
-        while (y !== this.Sentinel && y !== undefined && x === y.right) {
-            x = y;
-            y = y.parent;
-        }
-        return y;
-    }
-    /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function returns the predecessor of a given node in a red-black tree.
@@ -335,11 +322,11 @@ class RedBlackTree extends bst_1.BST {
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x) {
-        if (x.left !== this.Sentinel) {
+        if (this.isRealNode(x.left)) {
             return this.getRightMost(x.left);
         }
         let y = x.parent;
-        while (y !== this.Sentinel && x === y.left) {
+        while (this.isRealNode(y) && x === y.left) {
             x = y;
             y = y.parent;
         }

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeKeyOrNode, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
@@ -48,6 +48,13 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * class.
      */
     isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it

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

@@ -60,6 +60,15 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     isNode(exemplar) {
         return exemplar instanceof TreeMultimapNode;
     }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
      * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, which means it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.48.9",
+  "version": "1.49.0",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {

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

@@ -14,7 +14,7 @@ import type {
   BSTNodeKeyOrNode,
   BTNodeExemplar
 } from '../../types';
-import { BTNCallback } from '../../types';
+import { BTNCallback, BTNodeKeyOrNode } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
@@ -90,6 +90,16 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
     return exemplar instanceof AVLTreeNode;
   }
 
+  /**
+   * The function "isNotNodeInstance" checks if a potential key is a K.
+   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+   * data type.
+   * @returns a boolean value indicating whether the potentialKey is of type number or not.
+   */
+  override isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof AVLTreeNode)
+  }
+
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.

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

@@ -1236,8 +1236,8 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
    * @returns a boolean value.
    */
-  isRealNode(node: any): node is N {
-    return node instanceof BinaryTreeNode && node.key.toString() !== 'NaN';
+  isRealNode(node: BTNodeExemplar<K, V, N>): node is N {
+    return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
   }
 
   /**
@@ -1245,8 +1245,8 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
    * @returns a boolean value.
    */
-  isNIL(node: any) {
-    return node instanceof BinaryTreeNode && node.key.toString() === 'NaN';
+  isNIL(node: BTNodeExemplar<K, V, N>) {
+    return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
   }
 
   /**
@@ -1254,12 +1254,12 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
    * @returns a boolean value.
    */
-  isNodeOrNull(node: any): node is N | null {
+  isNodeOrNull(node: BTNodeExemplar<K, V, N>): node is N | null {
     return this.isRealNode(node) || node === null;
   }
 
   /**
-   * The function "isNotNodeInstance" checks if a potential key is a number.
+   * The function "isNotNodeInstance" checks if a potential key is a K.
    * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
    * data type.
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
@@ -1606,26 +1606,24 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   }
 
   /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
-  getPredecessor(node: N): N;
-
   /**
-   * The function `getPredecessor` returns the predecessor node of a given node in a binary tree.
-   * @param {K | N | null | undefined} node - The `node` parameter can be of type `K`, `N`,
-   * `null`, or `undefined`.
-   * @returns The function `getPredecessor` returns a value of type `N | undefined`.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   *
+   * The function returns the predecessor of a given node in a tree.
+   * @param {N} node - The parameter `node` is of type `RedBlackTreeNode`, which represents a node in a
+   * tree.
+   * @returns the predecessor of the given 'node'.
    */
-  getPredecessor(node: BTNodeKeyOrNode<K, N>): N | undefined {
-    node = this.ensureNode(node);
-    if (!this.isRealNode(node)) return undefined;
-
-    if (node.left) {
+  getPredecessor(node: N): N {
+    if (this.isRealNode(node.left)) {
       let predecessor: N | null | undefined = node.left;
       while (!this.isRealNode(predecessor) || (this.isRealNode(predecessor.right) && predecessor.right !== node)) {
-        if (predecessor) {
+        if (this.isRealNode(predecessor)) {
           predecessor = predecessor.right;
         }
       }
@@ -1642,15 +1640,16 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * after the given node in the inorder traversal of the binary tree.
    */
   getSuccessor(x?: K | N | null): N | null | undefined {
+
     x = this.ensureNode(x);
-    if (!x) return undefined;
+    if (!this.isRealNode(x)) return undefined;
 
-    if (x.right) {
+    if (this.isRealNode(x.right)) {
       return this.getLeftMost(x.right);
     }
 
     let y: N | null | undefined = x.parent;
-    while (y && y && x === y.right) {
+    while (this.isRealNode(y) && x === y.right) {
       x = y;
       y = y.parent;
     }

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

@@ -14,7 +14,7 @@ import type {
   BTNodeExemplar,
   BTNodePureExemplar
 } from '../../types';
-import { BSTVariant, CP, IterationType } from '../../types';
+import { BSTVariant, BTNodeKeyOrNode, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
@@ -442,6 +442,16 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     }
   }
 
+  /**
+   * The function "isNotNodeInstance" checks if a potential key is a K.
+   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+   * data type.
+   * @returns a boolean value indicating whether the potentialKey is of type number or not.
+   */
+  override isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof BSTNode)
+  }
+
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree.
    * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.

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

@@ -11,6 +11,7 @@ import {
   BSTNodeKeyOrNode,
   BTNCallback,
   BTNodeExemplar,
+  BTNodeKeyOrNode,
   IterationType,
   RBTNColor,
   RBTreeOptions,
@@ -115,6 +116,16 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
     return exemplar instanceof RedBlackTreeNode;
   }
 
+  /**
+   * The function "isNotNodeInstance" checks if a potential key is a K.
+   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+   * data type.
+   * @returns a boolean value indicating whether the potentialKey is of type number or not.
+   */
+  override isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof RedBlackTreeNode)
+  }
+
   /**
    * The function `exemplarToNode` takes an exemplar and converts it into a node object if possible.
    * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where:
@@ -300,7 +311,8 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    */
 
   override isRealNode(node: N | undefined): node is N {
-    return node !== this.Sentinel && node !== undefined;
+    if (node === this.Sentinel || node === undefined) return false;
+    return node instanceof RedBlackTreeNode;
   }
 
   getNode<C extends BTNCallback<N, K>>(
@@ -362,38 +374,12 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   }
 
   /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   *
-   * The function returns the successor of a given node in a red-black tree.
-   * @param {RedBlackTreeNode} x - RedBlackTreeNode - The node for which we want to find the successor.
-   * @returns the successor of the given RedBlackTreeNode.
-   */
-  override getSuccessor(x: N): N | undefined {
-    if (x.right !== this.Sentinel) {
-      return this.getLeftMost(x.right) ?? undefined;
-    }
-
-    let y: N | undefined = x.parent;
-    while (y !== this.Sentinel && y !== undefined && x === y.right) {
-      x = y;
-      y = y.parent;
-    }
-    return y;
-  }
-
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
    * The function returns the predecessor of a given node in a red-black tree.
@@ -402,12 +388,12 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
    * @returns the predecessor of the given RedBlackTreeNode 'x'.
    */
   override getPredecessor(x: N): N {
-    if (x.left !== this.Sentinel) {
-      return this.getRightMost(x.left!)!;
+    if (this.isRealNode(x.left)) {
+      return this.getRightMost(x.left)!;
     }
 
     let y: N | undefined = x.parent;
-    while (y !== this.Sentinel && x === y!.left) {
+    while (this.isRealNode(y) && x === y.left) {
       x = y!;
       y = y!.parent;
     }

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

@@ -6,7 +6,14 @@
  * @license MIT License
  */
 import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, FamilyPosition, IterationType, TreeMultimapNested } from '../../types';
+import {
+  BiTreeDeleteResult,
+  BTNCallback,
+  BTNodeKeyOrNode,
+  FamilyPosition,
+  IterationType,
+  TreeMultimapNested
+} from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -85,6 +92,15 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
     return exemplar instanceof TreeMultimapNode;
   }
 
+  /**
+   * The function "isNotNodeInstance" checks if a potential key is a K.
+   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+   * data type.
+   * @returns a boolean value indicating whether the potentialKey is of type number or not.
+   */
+  override isNotNodeInstance(potentialKey: BTNodeKeyOrNode<K, N>): potentialKey is K {
+    return !(potentialKey instanceof TreeMultimapNode)
+  }
 
   /**
    * The function `exemplarToNode` converts an exemplar object into a node object.