deque-typed 1.50.9 → 1.51.1

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

@@ -194,7 +194,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * decremented by 1 and
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
         var _a;
         const deletedResult = [];
         if (!this.root)

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

@@ -108,7 +108,7 @@ export declare class AVLTree<K = any, V = any, NODE extends AVLTreeNode<K, V, NO
      * `callback` function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
      * parameter of type `NODE
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */

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

@@ -133,11 +133,11 @@ class AVLTree extends bst_1.BST {
      * `callback` function.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-     * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+     * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
      * parameter of type `NODE
      * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         if (identifier instanceof AVLTreeNode)
             callback = (node => node);
         const deletedResults = super.delete(identifier, callback);

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

@@ -576,7 +576,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * 4. `middleIndex`: The index of the middle character
      */
     protected _displayAux(node: NODE | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
-    protected _defaultOneParamCallback: (node: NODE | null | undefined) => K | undefined;
+    protected _DEFAULT_CALLBACK: (node: NODE | null | undefined) => K | undefined;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {NODE} srcNode - The source node to swap.

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

@@ -107,7 +107,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = 'ITERATIVE';
         this._extractor = (key) => (typeof key === 'number' ? key : Number(key));
-        this._defaultOneParamCallback = (node) => (node ? node.key : undefined);
+        this._DEFAULT_CALLBACK = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
             if (iterationType)
@@ -217,23 +217,23 @@ class BinaryTree extends base_1.IterableEntryBase {
      * itself if it is not a valid node key.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
-            res = keyOrNodeOrEntry;
+            return keyOrNodeOrEntry;
         }
         else if (this.isEntry(keyOrNodeOrEntry)) {
             if (keyOrNodeOrEntry[0] === null)
-                res = null;
-            else if (keyOrNodeOrEntry[0] !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+                return null;
+            if (keyOrNodeOrEntry[0] === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
         }
         else {
             if (keyOrNodeOrEntry === null)
-                res = null;
-            else if (keyOrNodeOrEntry !== undefined)
-                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+                return null;
+            if (keyOrNodeOrEntry === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
-        return res;
     }
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
@@ -409,14 +409,14 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specific node based on its value or object.
      * @param {C} callback - The `callback` parameter is a function that is used to determine the
      * identifier of the node to be deleted. It is optional and has a default value of
-     * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+     * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
      * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         const deletedResult = [];
         if (!this.root)
             return deletedResult;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         const curr = this.getNode(identifier, callback);
         if (!curr)
@@ -475,7 +475,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * specific value.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `C`. It is used to determine if a node matches the given
-     * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+     * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
      * default
      * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
      * matches the identifier. If set to true, the function will stop iterating once it finds a matching
@@ -488,15 +488,15 @@ class BinaryTree extends base_1.IterableEntryBase {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `NODE`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    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 [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
                     if (onlyOne)
@@ -504,23 +504,23 @@ class BinaryTree extends base_1.IterableEntryBase {
                 }
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && dfs(cur.left);
+                cur.right && dfs(cur.right);
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [beginRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (cur) {
                     if (callback(cur) === identifier) {
                         ans.push(cur);
                         if (onlyOne)
                             return ans;
                     }
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    cur.left && stack.push(cur.left);
+                    cur.right && stack.push(cur.right);
                 }
             }
         }
@@ -551,9 +551,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * nodes are visited during the search.
      * @returns a value of type `NODE | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
@@ -579,27 +579,27 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!this.root)
             return undefined;
         if (iterationType === 'RECURSIVE') {
-            const _dfs = (cur) => {
+            const dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!cur.left && !cur.right)
                     return;
                 if (cur.left)
-                    return _dfs(cur.left);
+                    return dfs(cur.left);
                 if (cur.right)
-                    return _dfs(cur.right);
+                    return dfs(cur.right);
             };
-            return _dfs(this.root);
+            return dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [this.root];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (cur) {
                     if (cur.key === key)
                         return cur;
-                    cur.left && queue.push(cur.left);
-                    cur.right && queue.push(cur.right);
+                    cur.left && stack.push(cur.left);
+                    cur.right && stack.push(cur.right);
                 }
             }
         }
@@ -630,9 +630,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b;
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
@@ -661,8 +661,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
+    has(identifier, callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
+        if ((!callback || callback === this._DEFAULT_CALLBACK) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
@@ -967,21 +967,21 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!this.isRealNode(beginRoot))
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse(cur.left);
+                return dfs(cur.left);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const dfs = (0, utils_1.trampoline)((cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
-                return _traverse.cont(cur.left);
+                return dfs.cont(cur.left);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1011,21 +1011,21 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!beginRoot)
             return beginRoot;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse(cur.right);
+                return dfs(cur.right);
             };
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const dfs = (0, utils_1.trampoline)((cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
-                return _traverse.cont(cur.right);
+                return dfs.cont(cur.right);
             });
-            return _traverse(beginRoot);
+            return dfs(beginRoot);
         }
     }
     /**
@@ -1110,65 +1110,65 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `false`, null or undefined
      * @returns an array of values that are the return values of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (node) => {
+            const dfs = (node) => {
                 switch (pattern) {
                     case 'IN':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'PRE':
                         if (includeNull) {
                             this.isNodeOrNull(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         else {
                             this.isRealNode(node) && ans.push(callback(node));
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                         }
                         break;
                     case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isNodeOrNull(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isNodeOrNull(node) && ans.push(callback(node));
                         }
                         else {
                             if (this.isRealNode(node) && this.isRealNode(node.left))
-                                _traverse(node.left);
+                                dfs(node.left);
                             if (this.isRealNode(node) && this.isRealNode(node.right))
-                                _traverse(node.right);
+                                dfs(node.right);
                             this.isRealNode(node) && ans.push(callback(node));
                         }
                         break;
                 }
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
             // 0: visit, 1: print
@@ -1241,14 +1241,14 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const queue = new queue_1.Queue([beginRoot]);
-            const traverse = (level) => {
+            const dfs = (level) => {
                 if (queue.size === 0)
                     return;
                 const current = queue.shift();
@@ -1265,9 +1265,9 @@ class BinaryTree extends base_1.IterableEntryBase {
                     if (this.isRealNode(current.right))
                         queue.push(current.right);
                 }
-                traverse(level + 1);
+                dfs(level + 1);
             };
-            traverse(0);
+            dfs(0);
         }
         else {
             const queue = new queue_1.Queue([beginRoot]);
@@ -1318,7 +1318,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1390,7 +1390,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root) {
+    morris(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root) {
         beginRoot = this.ensureNode(beginRoot);
         if (beginRoot === null)
             return [];

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

@@ -165,19 +165,19 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
-        let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
-            res = keyOrNodeOrEntry;
+            return keyOrNodeOrEntry;
         }
         else if (this.isEntry(keyOrNodeOrEntry)) {
-            if (keyOrNodeOrEntry[0])
-                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+            if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
         }
         else {
-            if (keyOrNodeOrEntry)
-                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+            if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined)
+                return;
+            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
         }
-        return res;
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -361,33 +361,33 @@ class BST extends binary_tree_1.BinaryTree {
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key, iterationType = 'ITERATIVE') {
-        // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
+        // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
         if (!this.isRealNode(this.root))
-            return undefined;
+            return;
         if (iterationType === 'RECURSIVE') {
-            const _dfs = (cur) => {
+            const dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left))
-                    return _dfs(cur.left);
-                if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right))
-                    return _dfs(cur.right);
+                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);
+            return dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            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._compare(cur.key, key) === 'GT')
-                        this.isRealNode(cur.left) && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === 'LT')
-                        this.isRealNode(cur.right) && queue.push(cur.right);
+                    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);
                 }
             }
         }
@@ -420,13 +420,13 @@ class BST extends binary_tree_1.BinaryTree {
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`NODE[]`).
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this._DEFAULT_CALLBACK, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
                     ans.push(cur);
@@ -436,18 +436,18 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
                 // TODO potential bug
-                if (callback === this._defaultOneParamCallback) {
+                if (callback === this._DEFAULT_CALLBACK) {
                     if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
-                        _traverse(cur.left);
+                        dfs(cur.left);
                     if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
-                        _traverse(cur.right);
+                        dfs(cur.right);
                 }
                 else {
-                    this.isRealNode(cur.left) && _traverse(cur.left);
-                    this.isRealNode(cur.right) && _traverse(cur.right);
+                    this.isRealNode(cur.left) && dfs(cur.left);
+                    this.isRealNode(cur.right) && dfs(cur.right);
                 }
             };
-            _traverse(beginRoot);
+            dfs(beginRoot);
         }
         else {
             const stack = [beginRoot];
@@ -461,7 +461,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === this._defaultOneParamCallback) {
+                    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')
@@ -505,7 +505,7 @@ class BST extends binary_tree_1.BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
+    dfs(callback = this._DEFAULT_CALLBACK, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -529,7 +529,7 @@ class BST extends binary_tree_1.BinaryTree {
      * nodes are visited.
      * @returns The method is returning an array of the return type of the callback function.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return super.bfs(callback, beginRoot, iterationType, false);
     }
     /**
@@ -554,7 +554,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning a two-dimensional array of the return type of the callback
      * function.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return super.listLevels(callback, beginRoot, iterationType, false);
     }
     /**
@@ -617,7 +617,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNode(targetNode);
         const ans = [];
         if (!targetNode)
@@ -626,16 +626,16 @@ class BST extends binary_tree_1.BinaryTree {
             return ans;
         const targetKey = targetNode.key;
         if (iterationType === 'RECURSIVE') {
-            const _traverse = (cur) => {
+            const dfs = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
                 if (this.isRealNode(cur.left))
-                    _traverse(cur.left);
+                    dfs(cur.left);
                 if (this.isRealNode(cur.right))
-                    _traverse(cur.right);
+                    dfs(cur.right);
             };
-            _traverse(this.root);
+            dfs(this.root);
             return ans;
         }
         else {

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

@@ -187,7 +187,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * deleted is not found.
      * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
      * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
      * return the identifier of the node to
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */

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

@@ -190,7 +190,7 @@ class RedBlackTree extends bst_1.BST {
      * 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._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    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 ? _a : undefined;
     }
@@ -261,11 +261,11 @@ class RedBlackTree extends bst_1.BST {
      * deleted is not found.
      * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
      * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-     * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+     * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
      * return the identifier of the node to
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK) {
         if (identifier === null)
             return [];
         const results = [];

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

@@ -145,7 +145,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * function. It can also be null or undefined if no node needs to be deleted.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
      * used
      * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
      * node when performing deletion. If set to true, the count of the target node will not be considered

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

@@ -198,7 +198,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * function. It can also be null or undefined if no node needs to be deleted.
      * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
      * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-     * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+     * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
      * used
      * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
      * node when performing deletion. If set to true, the count of the target node will not be considered
@@ -206,7 +206,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * target node will be decremented
      * @returns an array of BinaryTreeDeleteResult<NODE> objects.
      */
-    delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
+    delete(identifier, callback = this._DEFAULT_CALLBACK, ignoreCount = false) {
         if (identifier === null)
             return [];
         const results = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deque-typed",
-  "version": "1.50.9",
+  "version": "1.51.1",
   "description": "Deque. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -119,6 +119,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.9"
+    "data-structure-typed": "^1.51.0"
   }
 }

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

@@ -240,7 +240,7 @@ export class AVLTreeMultiMap<
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];

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

@@ -164,13 +164,13 @@ export class AVLTree<
    * `callback` function.
    * @param {C} callback - The `callback` parameter is a function that will be called for each node
    * that is deleted from the binary tree. It is an optional parameter and if not provided, it will
-   * default to the `_defaultOneParamCallback` function. The `callback` function should have a single
+   * default to the `_DEFAULT_CALLBACK` function. The `callback` function should have a single
    * parameter of type `NODE
    * @returns The method is returning an array of `BinaryTreeDeleteResult<NODE>`.
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultOneParamCallback as 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);

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

@@ -268,17 +268,17 @@ export class BinaryTree<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | null | undefined {
-    let res: NODE | null | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
-      res = keyOrNodeOrEntry;
+      return keyOrNodeOrEntry;
     } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0] === null) res = null;
-      else if (keyOrNodeOrEntry[0] !== undefined) res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      if (keyOrNodeOrEntry[0] === null) return null;
+      if (keyOrNodeOrEntry[0] === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
     } else {
-      if (keyOrNodeOrEntry === null) res = null;
-      else if (keyOrNodeOrEntry !== undefined) res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      if (keyOrNodeOrEntry === null) return null;
+      if (keyOrNodeOrEntry === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
-    return res;
   }
 
   /**
@@ -486,16 +486,16 @@ export class BinaryTree<
    * specific node based on its value or object.
    * @param {C} callback - The `callback` parameter is a function that is used to determine the
    * identifier of the node to be deleted. It is optional and has a default value of
-   * `this._defaultOneParamCallback`. The `callback` function should return the identifier of the node.
+   * `this._DEFAULT_CALLBACK`. The `callback` function should return the identifier of the node.
    * @returns an array of `BinaryTreeDeleteResult<NODE>`.
    */
   delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C
+    callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
     const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
 
     const curr = this.getNode(identifier, callback);
@@ -579,7 +579,7 @@ export class BinaryTree<
    * specific value.
    * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
    * input and returns a value of type `C`. It is used to determine if a node matches the given
-   * identifier. If no callback is provided, the `_defaultOneParamCallback` function is used as the
+   * identifier. If no callback is provided, the `_DEFAULT_CALLBACK` function is used as the
    * default
    * @param [onlyOne=false] - A boolean value indicating whether to only return the first node that
    * matches the identifier. If set to true, the function will stop iterating once it finds a matching
@@ -594,12 +594,12 @@ export class BinaryTree<
    */
   getNodes<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
@@ -607,28 +607,28 @@ export class BinaryTree<
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE) => {
+      const dfs = (cur: NODE) => {
         if (callback(cur) === identifier) {
           ans.push(cur);
           if (onlyOne) return;
         }
         if (!cur.left && !cur.right) return;
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
+        cur.left && dfs(cur.left);
+        cur.right && dfs(cur.right);
       };
 
-      _traverse(beginRoot);
+      dfs(beginRoot);
     } else {
-      const queue = new Queue<NODE>([beginRoot]);
-      while (queue.size > 0) {
-        const cur = queue.shift();
+      const stack = [beginRoot];
+      while (stack.length > 0) {
+        const cur = stack.pop();
         if (cur) {
           if (callback(cur) === identifier) {
             ans.push(cur);
             if (onlyOne) return ans;
           }
-          cur.left && queue.push(cur.left);
-          cur.right && queue.push(cur.right);
+          cur.left && stack.push(cur.left);
+          cur.right && stack.push(cur.right);
         }
       }
     }
@@ -685,11 +685,11 @@ export class BinaryTree<
    */
   getNode<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
@@ -717,23 +717,23 @@ export class BinaryTree<
   getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
     if (!this.root) return undefined;
     if (iterationType === 'RECURSIVE') {
-      const _dfs = (cur: NODE): NODE | undefined => {
+      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);
+        if (cur.left) return dfs(cur.left);
+        if (cur.right) return dfs(cur.right);
       };
 
-      return _dfs(this.root);
+      return dfs(this.root);
     } else {
-      const queue = new Queue<NODE>([this.root]);
-      while (queue.size > 0) {
-        const cur = queue.shift();
+      const stack = [this.root];
+      while (stack.length > 0) {
+        const cur = stack.pop();
         if (cur) {
           if (cur.key === key) return cur;
-          cur.left && queue.push(cur.left);
-          cur.right && queue.push(cur.right);
+          cur.left && stack.push(cur.left);
+          cur.right && stack.push(cur.right);
         }
       }
     }
@@ -789,11 +789,11 @@ export class BinaryTree<
    */
   override get<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): V | undefined {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
 
     return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
@@ -848,11 +848,11 @@ export class BinaryTree<
    */
   override has<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): boolean {
-    if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
+    if ((!callback || callback === this._DEFAULT_CALLBACK) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
 
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -1184,20 +1184,20 @@ export class BinaryTree<
     if (!this.isRealNode(beginRoot)) return beginRoot;
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE): NODE => {
+      const dfs = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.left)) return cur;
-        return _traverse(cur.left);
+        return dfs(cur.left);
       };
 
-      return _traverse(beginRoot);
+      return dfs(beginRoot);
     } else {
       // Indirect implementation of iteration using tail recursion optimization
-      const _traverse = trampoline((cur: NODE) => {
+      const dfs = trampoline((cur: NODE) => {
         if (!this.isRealNode(cur.left)) return cur;
-        return _traverse.cont(cur.left);
+        return dfs.cont(cur.left);
       });
 
-      return _traverse(beginRoot);
+      return dfs(beginRoot);
     }
   }
 
@@ -1231,20 +1231,20 @@ export class BinaryTree<
     if (!beginRoot) return beginRoot;
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE): NODE => {
+      const dfs = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.right)) return cur;
-        return _traverse(cur.right);
+        return dfs(cur.right);
       };
 
-      return _traverse(beginRoot);
+      return dfs(beginRoot);
     } else {
       // Indirect implementation of iteration using tail recursion optimization
-      const _traverse = trampoline((cur: NODE) => {
+      const dfs = trampoline((cur: NODE) => {
         if (!this.isRealNode(cur.right)) return cur;
-        return _traverse.cont(cur.right);
+        return dfs.cont(cur.right);
       });
 
-      return _traverse(beginRoot);
+      return dfs(beginRoot);
     }
   }
 
@@ -1351,7 +1351,7 @@ export class BinaryTree<
    * @returns an array of values that are the return values of the callback function.
    */
   dfs<C extends BTNCallback<NODE | null | undefined>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE',
@@ -1361,38 +1361,38 @@ export class BinaryTree<
     if (!beginRoot) return [];
     const ans: ReturnType<C>[] = [];
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (node: NODE | null | undefined) => {
+      const dfs = (node: NODE | null | undefined) => {
         switch (pattern) {
           case 'IN':
             if (includeNull) {
-              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) dfs(node.left);
               this.isNodeOrNull(node) && ans.push(callback(node));
-              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) dfs(node.right);
             } else {
-              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) dfs(node.left);
               this.isRealNode(node) && ans.push(callback(node));
-              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) dfs(node.right);
             }
             break;
           case 'PRE':
             if (includeNull) {
               this.isNodeOrNull(node) && ans.push(callback(node));
-              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
-              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) dfs(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) dfs(node.right);
             } else {
               this.isRealNode(node) && ans.push(callback(node));
-              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
-              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) dfs(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) dfs(node.right);
             }
             break;
           case 'POST':
             if (includeNull) {
-              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
-              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.left)) dfs(node.left);
+              if (this.isRealNode(node) && this.isNodeOrNull(node.right)) dfs(node.right);
               this.isNodeOrNull(node) && ans.push(callback(node));
             } else {
-              if (this.isRealNode(node) && this.isRealNode(node.left)) _traverse(node.left);
-              if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
+              if (this.isRealNode(node) && this.isRealNode(node.left)) dfs(node.left);
+              if (this.isRealNode(node) && this.isRealNode(node.right)) dfs(node.right);
               this.isRealNode(node) && ans.push(callback(node));
             }
 
@@ -1400,7 +1400,7 @@ export class BinaryTree<
         }
       };
 
-      _traverse(beginRoot);
+      dfs(beginRoot);
     } else {
       // 0: visit, 1: print
       const stack: { opt: 0 | 1; node: NODE | null | undefined }[] = [{ opt: 0, node: beginRoot }];
@@ -1486,7 +1486,7 @@ export class BinaryTree<
    * the breadth-first traversal of a binary tree.
    */
   bfs<C extends BTNCallback<NODE | null>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType,
     includeNull = false
@@ -1499,7 +1499,7 @@ export class BinaryTree<
     if (iterationType === 'RECURSIVE') {
       const queue: Queue<NODE | null | undefined> = new Queue<NODE | null | undefined>([beginRoot]);
 
-      const traverse = (level: number) => {
+      const dfs = (level: number) => {
         if (queue.size === 0) return;
 
         const current = queue.shift()!;
@@ -1513,10 +1513,10 @@ export class BinaryTree<
           if (this.isRealNode(current.right)) queue.push(current.right);
         }
 
-        traverse(level + 1);
+        dfs(level + 1);
       };
 
-      traverse(0);
+      dfs(0);
     } else {
       const queue = new Queue<NODE | null | undefined>([beginRoot]);
       while (queue.size > 0) {
@@ -1580,7 +1580,7 @@ export class BinaryTree<
    * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
    */
   listLevels<C extends BTNCallback<NODE | null>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType,
     includeNull = false
@@ -1651,7 +1651,7 @@ export class BinaryTree<
    * by the return type of the `callback` function.
    */
   morris<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root
   ): ReturnType<C>[] {
@@ -1995,7 +1995,7 @@ export class BinaryTree<
     }
   }
 
-  protected _defaultOneParamCallback = (node: NODE | null | undefined) => (node ? node.key : undefined);
+  protected _DEFAULT_CALLBACK = (node: NODE | null | undefined) => (node ? node.key : undefined);
 
   /**
    * Swap the data of two nodes in the binary tree.

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

@@ -214,15 +214,15 @@ export class BST<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | undefined {
-    let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
-      res = keyOrNodeOrEntry;
+      return keyOrNodeOrEntry;
     } else if (this.isEntry(keyOrNodeOrEntry)) {
-      if (keyOrNodeOrEntry[0]) res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+      if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
     } else {
-      if (keyOrNodeOrEntry) res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) return;
+      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
-    return res;
   }
 
   /**
@@ -426,26 +426,26 @@ export class BST<
    * 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._defaultOneParamCallback, true, this.root, iterationType)[0];
-    if (!this.isRealNode(this.root)) return 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 => {
+      const dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left)) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right)) return _dfs(cur.right);
+        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);
+      return dfs(this.root);
     } else {
-      const queue = new Queue<NODE>([this.root]);
-      while (queue.size > 0) {
-        const cur = queue.shift();
+      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._compare(cur.key, key) === 'GT') this.isRealNode(cur.left) && queue.push(cur.left);
-          if (this._compare(cur.key, key) === 'LT') this.isRealNode(cur.right) && queue.push(cur.right);
+          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);
         }
       }
     }
@@ -481,7 +481,7 @@ export class BST<
    */
   override getNodes<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
@@ -491,7 +491,7 @@ export class BST<
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE) => {
+      const dfs = (cur: NODE) => {
         const callbackResult = callback(cur);
         if (callbackResult === identifier) {
           ans.push(cur);
@@ -500,16 +500,16 @@ export class BST<
 
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
-        if (callback === this._defaultOneParamCallback) {
-          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') _traverse(cur.left);
-          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') _traverse(cur.right);
+        if (callback === this._DEFAULT_CALLBACK) {
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') dfs(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') dfs(cur.right);
         } else {
-          this.isRealNode(cur.left) && _traverse(cur.left);
-          this.isRealNode(cur.right) && _traverse(cur.right);
+          this.isRealNode(cur.left) && dfs(cur.left);
+          this.isRealNode(cur.right) && dfs(cur.right);
         }
       };
 
-      _traverse(beginRoot);
+      dfs(beginRoot);
     } else {
       const stack = [beginRoot];
       while (stack.length > 0) {
@@ -521,7 +521,7 @@ export class BST<
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this._defaultOneParamCallback) {
+          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);
 
@@ -568,7 +568,7 @@ export class BST<
    * @returns The method is returning an array of the return type of the callback function.
    */
   override dfs<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE'
@@ -599,7 +599,7 @@ export class BST<
    * @returns The method is returning an array of the return type of the callback function.
    */
   override bfs<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -630,7 +630,7 @@ export class BST<
    * function.
    */
   override listLevels<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
@@ -700,7 +700,7 @@ export class BST<
    * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
    */
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
@@ -713,15 +713,15 @@ export class BST<
     const targetKey = targetNode.key;
 
     if (iterationType === 'RECURSIVE') {
-      const _traverse = (cur: NODE) => {
+      const dfs = (cur: NODE) => {
         const compared = this._compare(cur.key, targetKey);
         if (compared === lesserOrGreater) ans.push(callback(cur));
 
-        if (this.isRealNode(cur.left)) _traverse(cur.left);
-        if (this.isRealNode(cur.right)) _traverse(cur.right);
+        if (this.isRealNode(cur.left)) dfs(cur.left);
+        if (this.isRealNode(cur.right)) dfs(cur.right);
       };
 
-      _traverse(this.root);
+      dfs(this.root);
       return ans;
     } else {
       const queue = new Queue<NODE>([this.root]);

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

@@ -231,7 +231,7 @@ export class RedBlackTree<
    */
   override getNode<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
@@ -308,13 +308,13 @@ export class RedBlackTree<
    * deleted is not found.
    * @param {C} callback - The `callback` parameter is a function that is used to retrieve a node from
    * the binary tree based on its identifier. It is an optional parameter and if not provided, the
-   * `_defaultOneParamCallback` function is used as the default callback. The callback function should
+   * `_DEFAULT_CALLBACK` function is used as the default callback. The callback function should
    * return the identifier of the node to
    * @returns an array of BinaryTreeDeleteResult<NODE> objects.
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C
+    callback: C = this._DEFAULT_CALLBACK as C
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];

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

@@ -242,7 +242,7 @@ export class TreeMultiMap<
    * function. It can also be null or undefined if no node needs to be deleted.
    * @param {C} callback - The `callback` parameter is a function that takes a node of type `NODE` as
    * input and returns a value of type `ReturnType<C>`. It is used to determine if a node matches the
-   * identifier for deletion. If no callback is provided, the `_defaultOneParamCallback` function is
+   * identifier for deletion. If no callback is provided, the `_DEFAULT_CALLBACK` function is
    * used
    * @param [ignoreCount=false] - A boolean value indicating whether to ignore the count of the target
    * node when performing deletion. If set to true, the count of the target node will not be considered
@@ -252,7 +252,7 @@ export class TreeMultiMap<
    */
   override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C> | null | undefined,
-    callback: C = this._defaultOneParamCallback as C,
+    callback: C = this._DEFAULT_CALLBACK as C,
     ignoreCount = false
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];