min-heap-typed 1.51.5 → 1.51.7

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

@@ -199,6 +199,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
         const deletedResult = [];
         if (!this.root)
             return deletedResult;
+        callback = this._ensureCallback(identifier, callback);
         const curr = (_a = this.getNode(identifier, callback)) !== null && _a !== void 0 ? _a : undefined;
         if (!curr)
             return deletedResult;

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

@@ -138,8 +138,6 @@ class AVLTree extends bst_1.BST {
      * @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) {

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

@@ -254,7 +254,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @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;
+    getNodeByKey(key: K, iterationType?: IterationType): NODE | null | undefined;
     get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
@@ -606,4 +606,5 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * type `NODE` or `null`.
      */
     protected _setRoot(v: NODE | null | undefined): void;
+    protected _ensureCallback<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback?: C): C;
 }

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

@@ -225,23 +225,24 @@ class BinaryTree extends base_1.IterableEntryBase {
      * 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] === undefined)
-                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 === undefined)
+            if (key === undefined)
                 return;
-            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+            return this.getNodeByKey(key, iterationType);
         }
+        if (keyOrNodeOrEntry === null)
+            return null;
+        if (keyOrNodeOrEntry === undefined)
+            return;
+        return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
     /**
      * The function checks if a given node is a real node or null.
@@ -426,8 +427,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         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;
@@ -499,11 +499,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @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) => {
@@ -584,33 +583,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = 'ITERATIVE') {
-        if (!this.root)
-            return undefined;
-        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)
@@ -639,8 +612,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * 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 || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
+        var _a;
+        return (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value;
     }
     /**
      * Time Complexity: O(n)
@@ -668,8 +641,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @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;
     }
     /**
@@ -1766,5 +1738,11 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         this._root = v;
     }
+    _ensureCallback(identifier, callback = this._DEFAULT_CALLBACK) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+            callback = (node => node);
+        }
+        return callback;
+    }
 }
 exports.BinaryTree = BinaryTree;

package/dist/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/data-structures/binary-tree/bst.js

@@ -165,19 +165,21 @@ class BST extends binary_tree_1.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.
@@ -342,56 +344,6 @@ class BST extends binary_tree_1.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)
@@ -424,6 +376,7 @@ class BST extends binary_tree_1.BinaryTree {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
+        callback = this._ensureCallback(identifier, callback);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -453,30 +406,28 @@ class BST extends binary_tree_1.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);
                 }
             }
         }
@@ -511,6 +462,27 @@ class BST extends binary_tree_1.BinaryTree {
         var _a;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : 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)
@@ -826,7 +798,11 @@ class BST extends binary_tree_1.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
@@ -840,10 +816,7 @@ class BST extends binary_tree_1.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
@@ -856,10 +829,7 @@ class BST extends binary_tree_1.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;
     }
 }
 exports.BST = BST;

package/dist/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/data-structures/binary-tree/rb-tree.js

@@ -214,6 +214,7 @@ class RedBlackTree extends bst_1.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;
@@ -598,5 +599,23 @@ class RedBlackTree extends bst_1.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';
+    }
 }
 exports.RedBlackTree = RedBlackTree;

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

@@ -210,6 +210,7 @@ class TreeMultiMap extends rb_tree_1.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.51.5",
+  "version": "1.51.7",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.51.5"
+    "data-structure-typed": "^1.51.7"
   }
 }

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

@@ -245,6 +245,7 @@ export class AVLTreeMultiMap<
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
+    callback = this._ensureCallback(identifier, callback);
 
     const curr: NODE | undefined = this.getNode(identifier, callback) ?? undefined;
     if (!curr) return deletedResult;

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

@@ -172,7 +172,6 @@ export class AVLTree<
     identifier: ReturnType<C>,
     callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
-    if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {

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

@@ -278,17 +278,19 @@ export class BinaryTree<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | null | undefined {
+    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] === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-    } else {
-      if (keyOrNodeOrEntry === null) return null;
-      if (keyOrNodeOrEntry === undefined) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null) return null;
+      if (key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+    if (keyOrNodeOrEntry === null) return null;
+    if (keyOrNodeOrEntry === undefined) return;
+    return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
   }
 
   /**
@@ -506,8 +508,7 @@ export class BinaryTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     const curr = this.getNode(identifier, callback);
     if (!curr) return deletedResult;
@@ -610,10 +611,9 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
 
     const ans: NODE[] = [];
 
@@ -722,29 +722,8 @@ export class BinaryTree<
    * @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 = 'ITERATIVE'): NODE | undefined {
-    if (!this.root) return undefined;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        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);
-        }
-      }
-    }
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | null | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
   }
 
   override get<C extends BTNCallback<NODE, K>>(
@@ -801,7 +780,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.value;
   }
 
   override has<C extends BTNCallback<NODE, K>>(
@@ -857,8 +836,7 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): boolean {
-    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
-      callback = (node => node) as C;
+    callback = this._ensureCallback(identifier, callback);
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
@@ -2070,4 +2048,15 @@ export class BinaryTree<
     }
     this._root = v;
   }
+
+  protected _ensureCallback<C extends BTNCallback<NODE>>(
+    identifier: ReturnType<C> | null | undefined,
+    callback: C = this._DEFAULT_CALLBACK as C
+  ): C {
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && this.isNode(identifier)) {
+      callback = (node => node) as C;
+    }
+
+    return callback;
+  }
 }

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

@@ -214,15 +214,20 @@ export class BST<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | undefined {
+    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) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null || key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+
+    const key = keyOrNodeOrEntry;
+    if (key === null || key === undefined) return;
+    return this.getNodeByKey(key, iterationType);
   }
 
   /**
@@ -406,51 +411,6 @@ export class BST<
     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`.
-   */
-  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
-    if (!this.isRealNode(this.root)) return;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        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)
@@ -488,6 +448,7 @@ export class BST<
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
@@ -513,29 +474,27 @@ export class BST<
     } else {
       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 as K) === 'LT') stack.push(cur.right);
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === '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 cur = stack.pop()!;
+        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 as K) === 'LT') stack.push(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === '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);
         }
       }
     }
@@ -578,6 +537,29 @@ export class BST<
     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`.
+   */
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -920,7 +902,9 @@ export class BST<
     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';
   }
 
   /**
@@ -935,10 +919,7 @@ export class BST<
   protected _lt(a: K, b: K): boolean {
     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;
   }
 
   /**
@@ -952,9 +933,6 @@ export class BST<
   protected _gt(a: K, b: K): boolean {
     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/src/data-structures/binary-tree/rb-tree.ts

@@ -6,7 +6,7 @@ import type {
   RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
-import { CRUD, RBTNColor } from '../../types';
+import { CP, CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
@@ -252,7 +252,7 @@ export class RedBlackTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-
+    callback = this._ensureCallback(identifier, callback);
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 
     if (!nodeToDelete) {
@@ -656,4 +656,21 @@ export class RedBlackTree<
     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).
+   */
+  protected override _compare(a: K, b: K): CP {
+    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/src/data-structures/binary-tree/tree-multi-map.ts

@@ -257,6 +257,7 @@ export class TreeMultiMap<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
+    callback = this._ensureCallback(identifier, callback);
 
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);