data-structure-typed 1.51.1 → 1.51.2

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

@@ -7740,6 +7740,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_extractor", (key) => typeof key === "number" ? key : Number(key));
       __publicField(this, "_root");
       __publicField(this, "_size");
+      __publicField(this, "_NIL", new BinaryTreeNode(NaN));
       __publicField(this, "_DEFAULT_CALLBACK", (node) => node ? node.key : void 0);
       if (options) {
         const { iterationType, extractor } = options;
@@ -7774,6 +7775,13 @@ var dataStructureTyped = (() => {
     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.
@@ -7860,6 +7868,14 @@ var dataStructureTyped = (() => {
         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>`.
@@ -7868,15 +7884,6 @@ var dataStructureTyped = (() => {
     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.
@@ -7884,7 +7891,9 @@ var dataStructureTyped = (() => {
      * @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.
@@ -7892,15 +7901,16 @@ var dataStructureTyped = (() => {
      * @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)
@@ -8116,24 +8126,24 @@ var dataStructureTyped = (() => {
             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);
       } else {
         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);
           }
         }
       }
@@ -8166,8 +8176,6 @@ var dataStructureTyped = (() => {
      */
     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 : null;
     }
     /**
@@ -8244,8 +8252,6 @@ var dataStructureTyped = (() => {
      */
     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 ? void 0 : _a.value) != null ? _b : void 0;
     }
     /**
@@ -9779,6 +9785,35 @@ var dataStructureTyped = (() => {
       }
       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;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -11178,20 +11213,12 @@ var dataStructureTyped = (() => {
      */
     constructor(keysOrNodesOrEntries = [], options) {
       super([], options);
-      __publicField(this, "_SENTINEL", new RedBlackTreeNode(NaN));
       __publicField(this, "_root");
-      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.
@@ -11276,53 +11303,6 @@ var dataStructureTyped = (() => {
     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 === void 0)
-        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;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -11336,7 +11316,7 @@ var dataStructureTyped = (() => {
      */
     clear() {
       super.clear();
-      this._root = this.SENTINEL;
+      this._root = this.NIL;
     }
     /**
      * Time Complexity: O(log n)
@@ -11491,9 +11471,9 @@ var dataStructureTyped = (() => {
       while (this.isRealNode(current)) {
         parent = current;
         if (node.key < current.key) {
-          current = (_a = current.left) != null ? _a : this.SENTINEL;
+          current = (_a = current.left) != null ? _a : this.NIL;
         } else if (node.key > current.key) {
-          current = (_b = current.right) != null ? _b : this.SENTINEL;
+          current = (_b = current.right) != null ? _b : this.NIL;
         } else {
           this._replaceNode(current, node);
           return "UPDATED";
@@ -11507,8 +11487,8 @@ var dataStructureTyped = (() => {
       } 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";