data-structure-typed 1.48.9 → 1.49.0

package/dist/umd/data-structure-typed.js

@@ -8248,7 +8248,7 @@ var dataStructureTyped = (() => {
      * @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.
@@ -8256,7 +8256,7 @@ var dataStructureTyped = (() => {
      * @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.
@@ -8267,7 +8267,7 @@ var dataStructureTyped = (() => {
       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.
@@ -8535,19 +8535,23 @@ var dataStructureTyped = (() => {
       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 void 0;
-      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;
           }
         }
@@ -8564,13 +8568,13 @@ var dataStructureTyped = (() => {
      */
     getSuccessor(x) {
       x = this.ensureNode(x);
-      if (!x)
+      if (!this.isRealNode(x))
         return void 0;
-      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;
       }
@@ -9299,6 +9303,15 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * 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.
@@ -10072,6 +10085,15 @@ var dataStructureTyped = (() => {
     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.
@@ -10503,6 +10525,15 @@ var dataStructureTyped = (() => {
     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:
@@ -10667,7 +10698,9 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     isRealNode(node) {
-      return node !== this.Sentinel && node !== void 0;
+      if (node === this.Sentinel || node === void 0)
+        return false;
+      return node instanceof RedBlackTreeNode;
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
@@ -10702,35 +10735,11 @@ var dataStructureTyped = (() => {
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
     /**
-     * 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;
-      }
-      let y = x.parent;
-      while (y !== this.Sentinel && y !== void 0 && 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.
@@ -10739,11 +10748,11 @@ var dataStructureTyped = (() => {
      * @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;
       }
@@ -11047,6 +11056,15 @@ var dataStructureTyped = (() => {
     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