data-structure-typed 1.51.6 → 1.51.7

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

@@ -161,25 +161,6 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
      */
     addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
-    /**
-     * 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: K, iterationType?: IterationType): NODE | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -235,6 +216,25 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @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(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: K, iterationType?: IterationType): NODE | undefined;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

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

@@ -169,19 +169,21 @@ export class BST extends BinaryTree {
      * @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] === undefined)
-                return;
-            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-        }
-        else {
-            if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined)
+        if (this.isEntry(keyOrNodeOrEntry)) {
+            const key = keyOrNodeOrEntry[0];
+            if (key === null || key === undefined)
                 return;
-            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+            return this.getNodeByKey(key, iterationType);
         }
+        const key = keyOrNodeOrEntry;
+        if (key === null || key === undefined)
+            return;
+        return this.getNodeByKey(key, iterationType);
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -346,56 +348,6 @@ export class BST extends BinaryTree {
         }
         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') {
-        // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
-        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)
@@ -428,6 +380,7 @@ export class BST extends BinaryTree {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
+        callback = this._ensureCallback(identifier, callback);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -457,30 +410,28 @@ export class BST extends BinaryTree {
             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;
-                    }
-                    // TODO potential bug
-                    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);
-                        // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
-                        // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
-                        // // @ts-ignore
-                        // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
-                        // // @ts-ignore
-                        // if (this.isRealNode(cur.left) && cur.key < identifier) 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;
+                }
+                // TODO potential bug
+                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);
+                    // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
+                    // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
+                    // // @ts-ignore
+                    // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
+                    // // @ts-ignore
+                    // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
+                }
+                else {
+                    this.isRealNode(cur.right) && stack.push(cur.right);
+                    this.isRealNode(cur.left) && stack.push(cur.left);
                 }
             }
         }
@@ -514,6 +465,27 @@ export class BST extends BinaryTree {
     getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
+    /**
+     * 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)
@@ -828,7 +800,11 @@ export class BST extends BinaryTree {
         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
@@ -842,10 +818,7 @@ export class BST extends BinaryTree {
     _lt(a, b) {
         const extractedA = this.extractor(a);
         const extractedB = this.extractor(b);
-        // return this.variant === BSTVariant.STANDARD ? extractedA < extractedB : extractedA > extractedB;
         return this.variant === 'STANDARD' ? extractedA < extractedB : extractedA > extractedB;
-        // return extractedA < extractedB;
-        // return a < b;
     }
     /**
      * The function compares two values using a custom extractor function and returns true if the first
@@ -858,9 +831,6 @@ export class BST extends BinaryTree {
     _gt(a, b) {
         const extractedA = this.extractor(a);
         const extractedB = this.extractor(b);
-        // return this.variant === BSTVariant.STANDARD  ? extractedA > extractedB : extractedA < extractedB;
         return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
-        // return extractedA > extractedB;
-        // return a > b;
     }
 }

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

@@ -1,5 +1,5 @@
 import type { BinaryTreeDeleteResult, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { CRUD, RBTNColor } from '../../types';
+import { CP, CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -255,4 +255,13 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns void, which means it does not return any value.
      */
     protected _rightRotate(y: NODE | undefined): void;
+    /**
+     * 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).
+     */
+    protected _compare(a: K, b: K): CP;
 }

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

@@ -215,6 +215,7 @@ export class RedBlackTree extends BST {
         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;
@@ -596,4 +597,22 @@ export class RedBlackTree extends BST {
         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';
+    }
 }

package/dist/mjs/data-structures/binary-tree/tree-multi-map.js

@@ -209,6 +209,7 @@ export class TreeMultiMap extends RedBlackTree {
         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;

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;