min-heap-typed 1.39.3 → 1.39.4

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

@@ -50,7 +50,7 @@ export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`
+     * `((node: N) => node.key)`
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C): BinaryTreeDeletedResult<N>[];

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

@@ -63,10 +63,12 @@ class AVLTree extends bst_1.BST {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`
+     * `((node: N) => node.key)`
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete(identifier, callback = this._defaultCallbackByKey) {
+    delete(identifier, callback = ((node) => node.key)) {
+        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

@@ -180,8 +180,8 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns The method is returning a boolean value.
      */
     isPerfectlyBalanced(beginRoot?: N | null): boolean;
-    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
-    getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     has<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<N, N>>(identifier: N | null, callback?: C, beginRoot?: N, iterationType?: IterationType): boolean;
@@ -263,7 +263,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * function on each node according to a specified order pattern.
      * @param callback - The `callback` parameter is a function that will be called on each node during
      * the depth-first search traversal. It takes a node as input and returns a value. The default value
-     * is `this._defaultCallbackByKey`, which is a callback function defined elsewhere in the code.
+     * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. There are three possible values for `pattern`:
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -279,7 +279,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * function on each node.
      * @param callback - The `callback` parameter is a function that will be called for each node in the
      * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
      * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
      * will not be performed and an empty array will be returned.
@@ -315,7 +315,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * algorithm and returns an array of values obtained by applying a callback function to each node.
      * @param callback - The `callback` parameter is a function that will be called on each node in the
      * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-     * default value for this parameter is `this._defaultCallbackByKey`.
+     * default value for this parameter is `((node: N) => node.key)`.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
@@ -342,14 +342,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns {N} - The destination node after the swap.
      */
     protected _swap(srcNode: N, destNode: N): N;
-    /**
-     * Time complexity is O(n)
-     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-     * the tree's structure should be restored to its original state to maintain the tree's integrity.
-     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-     */
-    protected _defaultCallbackByKey: BTNCallback<N, BTNKey>;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -90,14 +90,6 @@ class BinaryTree {
         this._iterationType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
-        /**
-         * Time complexity is O(n)
-         * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-         * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-         * the tree's structure should be restored to its original state to maintain the tree's integrity.
-         * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-         */
-        this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this._iterationType = iterationType;
@@ -192,7 +184,7 @@ class BinaryTree {
             return;
         }
         const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-        const existNode = key !== undefined ? this.get(key, this._defaultCallbackByKey) : undefined;
+        const existNode = key !== undefined ? this.get(key, (node) => node.key) : undefined;
         if (this.root) {
             if (existNode) {
                 existNode.val = val;
@@ -262,9 +254,9 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`, which
+     * `((node: N) => node.key)`, which
      */
-    delete(identifier, callback = this._defaultCallbackByKey) {
+    delete(identifier, callback = ((node) => node.key)) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -455,7 +447,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`, which
+     * `((node: N) => node.key)`, which
      * @param [onlyOne=false] - A boolean value indicating whether to stop searching after finding the
      * first node that matches the identifier. If set to true, the function will return an array with
      * only one element (or an empty array if no matching node is found). If set to false (default), the
@@ -467,7 +459,7 @@ class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns The function `getNodes` returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         if (identifier instanceof BinaryTreeNode)
@@ -512,7 +504,7 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * `this._defaultCallbackByKey` is used if no callback function is
+     * `((node: N) => node.key)` is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the node from which the search should begin. By default, it is set to `this.root`, which means the
      * search will start from the root node of the binary tree. However, you can provide a different node
@@ -521,7 +513,7 @@ class BinaryTree {
      * performed when searching for nodes in the binary tree. It can have one of the following values:
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         // TODO may support finding node by value equal
@@ -535,14 +527,14 @@ class BinaryTree {
      * @param callback - The `callback` parameter is a function that is used to determine whether a node
      * matches the desired criteria. It takes a node as input and returns a boolean value indicating
      * whether the node matches the criteria or not. The default callback function
-     * (`this._defaultCallbackByKey`) is used if no callback function is
+     * (`((node: N) => node.key)`) is used if no callback function is
      * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
      * the root node from which the search should begin.
      * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
      * performed when searching for a node in the binary tree. It can have one of the following values:
      * @returns either the found node (of type N) or null if no node is found.
      */
-    get(identifier, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
@@ -705,7 +697,7 @@ class BinaryTree {
      * performed on the binary tree. It can have two possible values:
      * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    subTreeTraverse(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    subTreeTraverse(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot);
         const ans = [];
@@ -735,7 +727,7 @@ class BinaryTree {
      * function on each node according to a specified order pattern.
      * @param callback - The `callback` parameter is a function that will be called on each node during
      * the depth-first search traversal. It takes a node as input and returns a value. The default value
-     * is `this._defaultCallbackByKey`, which is a callback function defined elsewhere in the code.
+     * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
      * nodes are visited during the depth-first search. There are three possible values for `pattern`:
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -745,7 +737,7 @@ class BinaryTree {
      * iteration used in the depth-first search algorithm. It can have two possible values:
      * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
+    dfs(callback = ((node) => node.key), pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -820,7 +812,7 @@ class BinaryTree {
      * function on each node.
      * @param callback - The `callback` parameter is a function that will be called for each node in the
      * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
      * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
      * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
      * will not be performed and an empty array will be returned.
@@ -828,7 +820,7 @@ class BinaryTree {
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
      * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
      */
-    bfs(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -878,7 +870,7 @@ class BinaryTree {
      * level in a binary tree. Each inner array contains the return type of the provided callback
      * function `C` applied to the nodes at that level.
      */
-    listLevels(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const levelsNodes = [];
@@ -935,7 +927,7 @@ class BinaryTree {
      * algorithm and returns an array of values obtained by applying a callback function to each node.
      * @param callback - The `callback` parameter is a function that will be called on each node in the
      * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-     * default value for this parameter is `this._defaultCallbackByKey`.
+     * default value for this parameter is `((node: N) => node.key)`.
      * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
      * determines the order in which the nodes of a binary tree are traversed. It can have one of the
      * following values:
@@ -944,7 +936,7 @@ class BinaryTree {
      * `beginRoot` is `null`, an empty array will be returned.
      * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    morris(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root) {
+    morris(callback = ((node) => node.key), pattern = 'in', beginRoot = this.root) {
         if (beginRoot === null)
             return [];
         const ans = [];

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

@@ -97,7 +97,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+     * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array

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

@@ -223,7 +223,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either the first node that matches the given nodeProperty and callback, or null if no
      * matching node is found.
      */
-    get(identifier, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
@@ -259,7 +259,7 @@ class BST extends binary_tree_1.BinaryTree {
      * generic type `N`.
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-     * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+     * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
      * a
      * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
      * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -272,7 +272,7 @@ class BST extends binary_tree_1.BinaryTree {
      * traverse the binary tree. It can have one of the following values:
      * @returns an array of nodes (N[]).
      */
-    getNodes(identifier, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -287,7 +287,7 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!cur.left && !cur.right)
                     return;
                 // TODO potential bug
-                if (callback === this._defaultCallbackByKey) {
+                if (callback === ((node) => node.key)) {
                     if (this._compare(cur.key, identifier) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
                     if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -312,7 +312,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === this._defaultCallbackByKey) {
+                    if (callback === ((node) => node.key)) {
                         if (this._compare(cur.key, identifier) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
                         if (this._compare(cur.key, identifier) === types_1.CP.lt)
@@ -345,7 +345,7 @@ class BST extends binary_tree_1.BinaryTree {
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = ((node) => node.key), lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
             targetNode = this.get(targetNode);
         const ans = [];

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

@@ -98,7 +98,7 @@ export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = Tr
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`
+     * `((node: N) => node.key)`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be

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

@@ -251,14 +251,14 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @param callback - The `callback` parameter is a function that takes a node as input and returns a
      * value. This value is compared with the `identifier` parameter to determine if the node should be
      * included in the result. The `callback` parameter has a default value of
-     * `this._defaultCallbackByKey`
+     * `((node: N) => node.key)`
      * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
      * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete(identifier, callback = this._defaultCallbackByKey, ignoreCount = false) {
+    delete(identifier, callback = ((node) => node.key), ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;

package/package.json

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

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

@@ -71,13 +71,14 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`
+   * `((node: N) => node.key)`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultCallbackByKey as C
+    callback: C = ((node: N) => node.key) as C
   ): BinaryTreeDeletedResult<N>[] {
+    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

@@ -217,7 +217,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
 
     const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.get(key, this._defaultCallbackByKey) : undefined;
+    const existNode = key !== undefined ? this.get(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
       if (existNode) {
@@ -296,11 +296,11 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`, which
+   * `((node: N) => node.key)`, which
    */
   delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C
+    callback: C = ((node: N) => node.key) as C
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
@@ -487,7 +487,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   getNodes<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
-    callback: C,
+    callback?: C,
     onlyOne?: boolean,
     beginRoot?: N | null,
     iterationType?: IterationType
@@ -495,7 +495,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   getNodes<C extends BTNCallback<N, N>>(
     identifier: N | null,
-    callback: C,
+    callback?: C,
     onlyOne?: boolean,
     beginRoot?: N | null,
     iterationType?: IterationType
@@ -518,7 +518,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`, which
+   * `((node: N) => node.key)`, which
    * @param [onlyOne=false] - A boolean value indicating whether to stop searching after finding the
    * first node that matches the identifier. If set to true, the function will return an array with
    * only one element (or an empty array if no matching node is found). If set to false (default), the
@@ -532,7 +532,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -600,7 +600,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired criteria. It takes a node as input and returns a boolean value indicating
    * whether the node matches the criteria or not. The default callback function
-   * `this._defaultCallbackByKey` is used if no callback function is
+   * `((node: N) => node.key)` is used if no callback function is
    * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
    * the node from which the search should begin. By default, it is set to `this.root`, which means the
    * search will start from the root node of the binary tree. However, you can provide a different node
@@ -611,7 +611,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): boolean {
@@ -649,7 +649,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired criteria. It takes a node as input and returns a boolean value indicating
    * whether the node matches the criteria or not. The default callback function
-   * (`this._defaultCallbackByKey`) is used if no callback function is
+   * (`((node: N) => node.key)`) is used if no callback function is
    * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
    * the root node from which the search should begin.
    * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
@@ -658,7 +658,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -824,7 +824,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
   subTreeTraverse<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -860,7 +860,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function on each node according to a specified order pattern.
    * @param callback - The `callback` parameter is a function that will be called on each node during
    * the depth-first search traversal. It takes a node as input and returns a value. The default value
-   * is `this._defaultCallbackByKey`, which is a callback function defined elsewhere in the code.
+   * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
    * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
    * nodes are visited during the depth-first search. There are three possible values for `pattern`:
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -871,7 +871,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
    */
   dfs<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
     iterationType: IterationType = IterationType.ITERATIVE
@@ -946,7 +946,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function on each node.
    * @param callback - The `callback` parameter is a function that will be called for each node in the
    * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-   * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
+   * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
    * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
    * will not be performed and an empty array will be returned.
@@ -955,7 +955,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
    */
   bfs<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -1012,7 +1012,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function `C` applied to the nodes at that level.
    */
   listLevels<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[][] {
@@ -1071,7 +1071,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * algorithm and returns an array of values obtained by applying a callback function to each node.
    * @param callback - The `callback` parameter is a function that will be called on each node in the
    * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<BTNCallback<N>>`. The
-   * default value for this parameter is `this._defaultCallbackByKey`.
+   * default value for this parameter is `((node: N) => node.key)`.
    * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
    * determines the order in which the nodes of a binary tree are traversed. It can have one of the
    * following values:
@@ -1081,7 +1081,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
    */
   morris<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root
   ): ReturnType<C>[] {
@@ -1226,15 +1226,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return destNode;
   }
 
-  /**
-   * Time complexity is O(n)
-   * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-   * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-   * the tree's structure should be restored to its original state to maintain the tree's integrity.
-   * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-   */
-  protected _defaultCallbackByKey: BTNCallback<N, BTNKey> = node => node.key;
-
   /**
    * The function `_addTo` adds a new node to a binary tree if there is an available position.
    * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -234,7 +234,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   override get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -270,7 +270,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * generic type `N`.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-   * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+   * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
    * a
    * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
    * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -285,7 +285,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   override getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -303,7 +303,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
         if (!cur.left && !cur.right) return;
         // TODO potential bug
-        if (callback === this._defaultCallbackByKey) {
+        if (callback === ((node: N) => node.key)) {
           if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && _traverse(cur.left);
           if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && _traverse(cur.right);
         } else {
@@ -324,7 +324,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this._defaultCallbackByKey) {
+          if (callback === ((node: N) => node.key)) {
             if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && queue.push(cur.left);
             if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && queue.push(cur.right);
           } else {
@@ -358,7 +358,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
   lesserOrGreaterTraverse<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType

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

@@ -268,7 +268,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`
+   * `((node: N) => node.key)`
    * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
    * being deleted. If set to true, the count of the node will not be considered and the node will be
    * deleted regardless of its count. If set to false (default), the count of the node will be
@@ -277,7 +277,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     ignoreCount = false
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];