min-heap-typed 1.41.5 → 1.41.7

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
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @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

@@ -62,10 +62,10 @@ 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
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    delete(identifier, callback = ((node) => node.key)) {
+    delete(identifier, callback = this.defaultOneParamCallback) {
         if (identifier instanceof AVLTreeNode)
             callback = (node => node);
         const deletedResults = super.delete(identifier, callback);

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

@@ -79,6 +79,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
+    protected defaultOneParamCallback: (node: N) => number;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
@@ -257,7 +258,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 `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
+     * is `this.defaultOneParamCallback`, 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
@@ -273,7 +274,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 `((node: N) => node.key)
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
      * @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.
@@ -317,7 +318,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 `((node: N) => node.key)`.
+     * default value for this parameter is `this.defaultOneParamCallback`.
      * @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:

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

@@ -90,6 +90,7 @@ class BinaryTree {
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._root = null;
         this._size = 0;
+        this.defaultOneParamCallback = (node) => node.key;
         if (options !== undefined) {
             const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this.iterationType = iterationType;
@@ -242,9 +243,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
-     * `((node: N) => node.key)`, which
+     * `this.defaultOneParamCallback`, which
      */
-    delete(identifier, callback = ((node) => node.key)) {
+    delete(identifier, callback = this.defaultOneParamCallback) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -435,7 +436,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
-     * `((node: N) => node.key)`, which
+     * `this.defaultOneParamCallback`, 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
@@ -447,7 +448,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 = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         if (identifier instanceof BinaryTreeNode)
@@ -492,7 +493,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
-     * `((node: N) => node.key)` is used if no callback function is
+     * `this.defaultOneParamCallback` 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
@@ -501,7 +502,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 = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    has(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
@@ -514,14 +515,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
-     * (`((node: N) => node.key)`) is used if no callback function is
+     * (`this.defaultOneParamCallback`) 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.
      */
-    getNode(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    getNode(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
@@ -535,14 +536,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
-     * (`((node: N) => node.key)`) is used if no callback function is
+     * (`this.defaultOneParamCallback`) 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 value (of type V) or undefined if no node value is found.
      */
-    get(identifier, callback = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    get(identifier, callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b;
         if (identifier instanceof BinaryTreeNode)
             callback = (node => node);
@@ -704,7 +705,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 = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    subTreeTraverse(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
             beginRoot = this.getNode(beginRoot);
         const ans = [];
@@ -734,7 +735,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 `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
+     * is `this.defaultOneParamCallback`, 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
@@ -744,7 +745,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 = ((node) => node.key), pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
+    dfs(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -819,7 +820,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 `((node: N) => node.key)
+     * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
      * @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.
@@ -827,7 +828,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 = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -877,7 +878,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 = ((node) => node.key), beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const levelsNodes = [];
@@ -952,7 +953,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 `((node: N) => node.key)`.
+     * default value for this parameter is `this.defaultOneParamCallback`.
      * @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:
@@ -961,7 +962,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 = ((node) => node.key), pattern = 'in', beginRoot = this.root) {
+    morris(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
         if (beginRoot === null)
             return [];
         const ans = [];

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

@@ -54,25 +54,6 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The `addMany` function returns an array of `N`, `null`, or `undefined` values.
      */
     addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | null | undefined)[];
-    /**
-     * The function returns the first node in the binary tree that matches the given node property and
-     * callback.
-     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
-     * property of the binary tree node that you want to search for. It can be either a specific key
-     * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
-     * whether a node matches the desired property.
-     * @param callback - The `callback` parameter is a function that is used to determine whether a node
-     * matches the desired property. It takes a node as input and returns a boolean value indicating
-     * whether the node matches the property or not. If no callback function is provided, the default
-     * callback function `_defaultCallbackByKey` is used
-     * @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 is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary tree. It can have one of the following values:
-     * @returns either the first node that matches the given nodeProperty and callback, or null if no
-     * matching node is found.
-     */
-    getNode<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback?: C, beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
      * than, the key of the leftmost node if the comparison result is greater than, and the key of the
@@ -97,7 +78,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 `((node: N) => node.key)`, which is
+     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, 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

@@ -205,28 +205,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * The function returns the first node in the binary tree that matches the given node property and
-     * callback.
-     * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
-     * property of the binary tree node that you want to search for. It can be either a specific key
-     * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
-     * whether a node matches the desired property.
-     * @param callback - The `callback` parameter is a function that is used to determine whether a node
-     * matches the desired property. It takes a node as input and returns a boolean value indicating
-     * whether the node matches the property or not. If no callback function is provided, the default
-     * callback function `_defaultCallbackByKey` is used
-     * @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 is used to specify the type of iteration to
-     * be performed when searching for nodes in the binary tree. It can have one of the following values:
-     * @returns either the first node that matches the given nodeProperty and callback, or null if no
-     * matching node is found.
-     */
-    getNode(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;
-    }
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
      * than, the key of the leftmost node if the comparison result is greater than, and the key of the
@@ -259,7 +237,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 `((node: N) => node.key)`, which is
+     * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, 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 +250,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 = ((node) => node.key), onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+    getNodes(identifier, callback = this.defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -287,7 +265,7 @@ class BST extends binary_tree_1.BinaryTree {
                 if (!cur.left && !cur.right)
                     return;
                 // TODO potential bug
-                if (callback === ((node) => node.key)) {
+                if (callback === this.defaultOneParamCallback) {
                     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 +290,7 @@ class BST extends binary_tree_1.BinaryTree {
                             return ans;
                     }
                     // TODO potential bug
-                    if (callback === ((node) => node.key)) {
+                    if (callback === this.defaultOneParamCallback) {
                         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 +323,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 = ((node) => node.key), lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this.defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
             targetNode = this.getNode(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
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @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
-     * `((node: N) => node.key)`
+     * `this.defaultOneParamCallback`
      * @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 = ((node) => node.key), ignoreCount = false) {
+    delete(identifier, callback = this.defaultOneParamCallback, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;

package/dist/data-structures/graph/abstract-graph.js

@@ -172,21 +172,21 @@ class AbstractGraph {
             return [];
         }
         const dfs = (cur, dest, visiting, path) => {
-            visiting.set(cur, true);
+            visiting.add(cur);
             if (cur === dest) {
                 paths.push([vertex1, ...path]);
             }
             const neighbors = this.getNeighbors(cur);
             for (const neighbor of neighbors) {
-                if (!visiting.get(neighbor)) {
+                if (!visiting.has(neighbor)) {
                     path.push(neighbor);
                     dfs(neighbor, dest, visiting, path);
-                    (0, utils_1.arrayRemove)(path, (vertex) => vertex === neighbor);
+                    path.pop();
                 }
             }
-            visiting.set(cur, false);
+            visiting.delete(cur);
         };
-        dfs(vertex1, vertex2, new Map(), []);
+        dfs(vertex1, vertex2, new Set(), []);
         return paths;
     }
     /**

package/package.json

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

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

@@ -70,12 +70,12 @@ 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
-   * `((node: N) => node.key)`
+   * `this.defaultOneParamCallback`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = ((node: N) => node.key) as C
+    callback: C = this.defaultOneParamCallback as C
   ): BinaryTreeDeletedResult<N>[] {
     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

@@ -141,6 +141,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this._size;
   }
 
+  protected defaultOneParamCallback = (node: N) => node.key;
+  
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {BTNKey} key - The key for the new node.
@@ -284,11 +286,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
-   * `((node: N) => node.key)`, which
+   * `this.defaultOneParamCallback`, which
    */
   delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C
+    callback: C = this.defaultOneParamCallback as C
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
@@ -506,7 +508,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
-   * `((node: N) => node.key)`, which
+   * `this.defaultOneParamCallback`, 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
@@ -520,7 +522,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -588,7 +590,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
-   * `((node: N) => node.key)` is used if no callback function is
+   * `this.defaultOneParamCallback` 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
@@ -599,7 +601,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): boolean {
@@ -637,7 +639,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
-   * (`((node: N) => node.key)`) is used if no callback function is
+   * (`this.defaultOneParamCallback`) 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
@@ -646,7 +648,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -684,7 +686,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
-   * (`((node: N) => node.key)`) is used if no callback function is
+   * (`this.defaultOneParamCallback`) 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
@@ -693,7 +695,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): V | undefined {
@@ -859,7 +861,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -895,7 +897,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 `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
+   * is `this.defaultOneParamCallback`, 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
@@ -906,7 +908,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
     iterationType: IterationType = IterationType.ITERATIVE
@@ -981,7 +983,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 `((node: N) => node.key)
+   * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this.defaultOneParamCallback
    * @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.
@@ -990,7 +992,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -1047,7 +1049,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[][] {
@@ -1126,7 +1128,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 `((node: N) => node.key)`.
+   * default value for this parameter is `this.defaultOneParamCallback`.
    * @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:
@@ -1136,7 +1138,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root
   ): ReturnType<C>[] {

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

@@ -36,7 +36,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       }
     }
   }
-
+  
   /**
    * The function creates a new binary search tree node with the given key and value.
    * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -216,33 +216,6 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return inserted;
   }
 
-  /**
-   * The function returns the first node in the binary tree that matches the given node property and
-   * callback.
-   * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
-   * property of the binary tree node that you want to search for. It can be either a specific key
-   * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
-   * whether a node matches the desired property.
-   * @param callback - The `callback` parameter is a function that is used to determine whether a node
-   * matches the desired property. It takes a node as input and returns a boolean value indicating
-   * whether the node matches the property or not. If no callback function is provided, the default
-   * callback function `_defaultCallbackByKey` is used
-   * @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 is used to specify the type of iteration to
-   * be performed when searching for nodes in the binary tree. It can have one of the following values:
-   * @returns either the first node that matches the given nodeProperty and callback, or null if no
-   * matching node is found.
-   */
-  override getNode<C extends BTNCallback<N>>(
-    identifier: ReturnType<C> | null,
-    callback: C = ((node: N) => node.key) as C,
-    beginRoot = this.root,
-    iterationType = this.iterationType
-  ): N | null {
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
-  }
-
   /**
    * The function `lastKey` returns the key of the rightmost node if the comparison result is less
    * than, the key of the leftmost node if the comparison result is greater than, and the key of the
@@ -272,7 +245,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 `((node: N) => node.key)`, which is
+   * included in the result. The default value for `callback` is `this.defaultOneParamCallback`, 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
@@ -287,7 +260,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -305,7 +278,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 === ((node: N) => node.key)) {
+        if (callback === this.defaultOneParamCallback) {
           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 {
@@ -326,7 +299,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === ((node: N) => node.key)) {
+          if (callback === this.defaultOneParamCallback) {
             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 {
@@ -360,7 +333,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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback 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
-   * `((node: N) => node.key)`
+   * `this.defaultOneParamCallback`
    * @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 = ((node: N) => node.key) as C,
+    callback: C = this.defaultOneParamCallback as C,
     ignoreCount = false
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];

package/src/data-structures/graph/abstract-graph.ts

@@ -233,8 +233,8 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const dfs = (cur: VO, dest: VO, visiting: Map<VO, boolean>, path: VO[]) => {
-      visiting.set(cur, true);
+    const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
+      visiting.add(cur);
 
       if (cur === dest) {
         paths.push([vertex1, ...path]);
@@ -242,17 +242,17 @@ export abstract class AbstractGraph<
 
       const neighbors = this.getNeighbors(cur);
       for (const neighbor of neighbors) {
-        if (!visiting.get(neighbor)) {
+        if (!visiting.has(neighbor)) {
           path.push(neighbor);
           dfs(neighbor, dest, visiting, path);
-          arrayRemove(path, (vertex: VO) => vertex === neighbor);
+          path.pop();
         }
       }
 
-      visiting.set(cur, false);
+      visiting.delete(cur);
     };
 
-    dfs(vertex1, vertex2, new Map<VO, boolean>(), []);
+    dfs(vertex1, vertex2, new Set<VO>(), []);
     return paths;
   }