data-structure-typed 1.51.5 → 1.51.7

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

@@ -7860,21 +7860,24 @@ var dataStructureTyped = (() => {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
+      if (keyOrNodeOrEntry === this.NIL)
+        return;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         return keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        if (keyOrNodeOrEntry[0] === null)
-          return null;
-        if (keyOrNodeOrEntry[0] === void 0)
-          return;
-        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-      } else {
-        if (keyOrNodeOrEntry === null)
+      }
+      if (this.isEntry(keyOrNodeOrEntry)) {
+        const key = keyOrNodeOrEntry[0];
+        if (key === null)
           return null;
-        if (keyOrNodeOrEntry === void 0)
+        if (key === void 0)
           return;
-        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        return this.getNodeByKey(key, iterationType);
       }
+      if (keyOrNodeOrEntry === null)
+        return null;
+      if (keyOrNodeOrEntry === void 0)
+        return;
+      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -8052,8 +8055,7 @@ var dataStructureTyped = (() => {
       const deletedResult = [];
       if (!this.root)
         return deletedResult;
-      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
+      callback = this._ensureCallback(identifier, callback);
       const curr = this.getNode(identifier, callback);
       if (!curr)
         return deletedResult;
@@ -8121,11 +8123,10 @@ var dataStructureTyped = (() => {
      * @returns an array of nodes of type `NODE`.
      */
     getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
+      callback = this._ensureCallback(identifier, callback);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -8205,32 +8206,7 @@ var dataStructureTyped = (() => {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = "ITERATIVE") {
-      if (!this.root)
-        return void 0;
-      if (iterationType === "RECURSIVE") {
-        const dfs = (cur) => {
-          if (cur.key === key)
-            return cur;
-          if (!cur.left && !cur.right)
-            return;
-          if (cur.left)
-            return dfs(cur.left);
-          if (cur.right)
-            return dfs(cur.right);
-        };
-        return dfs(this.root);
-      } else {
-        const stack = [this.root];
-        while (stack.length > 0) {
-          const cur = stack.pop();
-          if (cur) {
-            if (cur.key === key)
-              return cur;
-            cur.left && stack.push(cur.left);
-            cur.right && stack.push(cur.right);
-          }
-        }
-      }
+      return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
     }
     /**
      * Time Complexity: O(n)
@@ -8259,8 +8235,8 @@ var dataStructureTyped = (() => {
      * found, `undefined` is returned.
      */
     get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-      var _a, _b;
-      return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
+      var _a;
+      return (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -8288,8 +8264,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
-      if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
-        callback = (node) => node;
+      callback = this._ensureCallback(identifier, callback);
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
     /**
@@ -9344,6 +9319,12 @@ var dataStructureTyped = (() => {
       }
       this._root = v;
     }
+    _ensureCallback(identifier, callback = this._DEFAULT_CALLBACK) {
+      if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+        callback = (node) => node;
+      }
+      return callback;
+    }
   };
 
   // src/data-structures/binary-tree/bst.ts
@@ -9501,17 +9482,21 @@ var dataStructureTyped = (() => {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = "ITERATIVE") {
+      if (keyOrNodeOrEntry === this.NIL)
+        return;
       if (this.isRealNode(keyOrNodeOrEntry)) {
         return keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === void 0)
-          return;
-        return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-      } else {
-        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0)
+      }
+      if (this.isEntry(keyOrNodeOrEntry)) {
+        const key2 = keyOrNodeOrEntry[0];
+        if (key2 === null || key2 === void 0)
           return;
-        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        return this.getNodeByKey(key2, iterationType);
       }
+      const key = keyOrNodeOrEntry;
+      if (key === null || key === void 0)
+        return;
+      return this.getNodeByKey(key, iterationType);
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -9666,54 +9651,6 @@ var dataStructureTyped = (() => {
       }
       return inserted;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-     * either recursive or iterative methods.
-     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
-     * It is used to identify the node that we want to retrieve.
-     * @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 (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
-     */
-    getNodeByKey(key, iterationType = "ITERATIVE") {
-      if (!this.isRealNode(this.root))
-        return;
-      if (iterationType === "RECURSIVE") {
-        const dfs = (cur) => {
-          if (cur.key === key)
-            return cur;
-          if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
-            return;
-          if (this.isRealNode(cur.left) && this._compare(cur.key, key) === "GT")
-            return dfs(cur.left);
-          if (this.isRealNode(cur.right) && this._compare(cur.key, key) === "LT")
-            return dfs(cur.right);
-        };
-        return dfs(this.root);
-      } else {
-        const stack = [this.root];
-        while (stack.length > 0) {
-          const cur = stack.pop();
-          if (this.isRealNode(cur)) {
-            if (this._compare(cur.key, key) === "EQ")
-              return cur;
-            if (this.isRealNode(cur.left) && this._compare(cur.key, key) === "GT")
-              stack.push(cur.left);
-            if (this.isRealNode(cur.right) && this._compare(cur.key, key) === "LT")
-              stack.push(cur.right);
-          }
-        }
-      }
-    }
     /**
        * Time Complexity: O(log n)
        * Space Complexity: O(k + log n)
@@ -9746,6 +9683,7 @@ var dataStructureTyped = (() => {
       beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
+      callback = this._ensureCallback(identifier, callback);
       const ans = [];
       if (iterationType === "RECURSIVE") {
         const dfs = (cur) => {
@@ -9772,22 +9710,20 @@ var dataStructureTyped = (() => {
         const stack = [beginRoot];
         while (stack.length > 0) {
           const cur = stack.pop();
-          if (this.isRealNode(cur)) {
-            const callbackResult = callback(cur);
-            if (callbackResult === identifier) {
-              ans.push(cur);
-              if (onlyOne)
-                return ans;
-            }
-            if (callback === this._DEFAULT_CALLBACK) {
-              if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
-                stack.push(cur.right);
-              if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
-                stack.push(cur.left);
-            } else {
-              this.isRealNode(cur.right) && stack.push(cur.right);
-              this.isRealNode(cur.left) && stack.push(cur.left);
-            }
+          const callbackResult = callback(cur);
+          if (callbackResult === identifier) {
+            ans.push(cur);
+            if (onlyOne)
+              return ans;
+          }
+          if (callback === this._DEFAULT_CALLBACK) {
+            if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === "LT")
+              stack.push(cur.right);
+            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === "GT")
+              stack.push(cur.left);
+          } else {
+            this.isRealNode(cur.right) && stack.push(cur.right);
+            this.isRealNode(cur.left) && stack.push(cur.left);
           }
         }
       }
@@ -9822,6 +9758,27 @@ var dataStructureTyped = (() => {
       var _a;
       return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) != null ? _a : void 0;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+     * either recursive or iterative methods.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
+     * It is used to identify the node that we want to retrieve.
+     * @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 (`NODE`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key, iterationType = "ITERATIVE") {
+      return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -10129,7 +10086,11 @@ var dataStructureTyped = (() => {
       const extractedA = this.extractor(a);
       const extractedB = this.extractor(b);
       const compared = this.variant === "STANDARD" ? extractedA - extractedB : extractedB - extractedA;
-      return compared > 0 ? "GT" : compared < 0 ? "LT" : "EQ";
+      if (compared > 0)
+        return "GT";
+      if (compared < 0)
+        return "LT";
+      return "EQ";
     }
     /**
      * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
@@ -10849,8 +10810,6 @@ var dataStructureTyped = (() => {
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._DEFAULT_CALLBACK) {
-      if (identifier instanceof AVLTreeNode)
-        callback = (node) => node;
       const deletedResults = super.delete(identifier, callback);
       for (const { needBalanced } of deletedResults) {
         if (needBalanced) {
@@ -11383,6 +11342,7 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return [];
       const results = [];
+      callback = this._ensureCallback(identifier, callback);
       const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
       if (!nodeToDelete) {
         return results;
@@ -11726,6 +11686,24 @@ var dataStructureTyped = (() => {
       x.right = y;
       y.parent = x;
     }
+    /**
+     * The function compares two values using a comparator function and returns whether the first value
+     * is greater than, less than, or equal to the second value.
+     * @param {K} a - The parameter "a" is of type K.
+     * @param {K} b - The parameter "b" in the above code represents a K.
+     * @returns a value of type CP (ComparisonResult). The possible return values are 'GT' (greater
+     * than), 'LT' (less than), or 'EQ' (equal).
+     */
+    _compare(a, b) {
+      const extractedA = this.extractor(a);
+      const extractedB = this.extractor(b);
+      const compared = extractedA - extractedB;
+      if (compared > 0)
+        return "GT";
+      if (compared < 0)
+        return "LT";
+      return "EQ";
+    }
   };
 
   // src/data-structures/binary-tree/avl-tree-multi-map.ts
@@ -11920,6 +11898,7 @@ var dataStructureTyped = (() => {
       const deletedResult = [];
       if (!this.root)
         return deletedResult;
+      callback = this._ensureCallback(identifier, callback);
       const curr = (_a = this.getNode(identifier, callback)) != null ? _a : void 0;
       if (!curr)
         return deletedResult;
@@ -12295,6 +12274,7 @@ var dataStructureTyped = (() => {
       if (identifier === null)
         return [];
       const results = [];
+      callback = this._ensureCallback(identifier, callback);
       const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
       if (!nodeToDelete) {
         return results;