min-heap-typed 1.41.8 → 1.42.0

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

@@ -238,67 +238,18 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @returns a boolean value.
      */
     isBST(iterationType?: IterationType): boolean;
-    /**
-     * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
-     * node, either recursively or iteratively.
-     * @param callback - The `callback` parameter is a function that will be called on each node in the
-     * subtree traversal. It takes a single argument, which is the current node being traversed, and
-     * returns a value. The return values from each callback invocation will be collected and returned as
-     * an array.
-     * @param {BTNKey | N | null} beginRoot - The `beginRoot` parameter is the starting point
-     * for traversing the subtree. It can be either a node object, a key value of a node, or `null` to
-     * start from the root of the tree.
-     * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-     * performed on the binary tree. It can have two possible values:
-     * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
-     */
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
-     * 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.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
-     * search. It determines where the search will begin in the tree or graph structure. If `beginRoot`
-     * is `null`, an empty array will be returned.
-     * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
-     * 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<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
-     * 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.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.
-     * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
-     * 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<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
-    /**
-     * The `listLevels` function takes a binary tree node and a callback function, and returns an array
-     * of arrays representing the levels of the tree.
-     * @param {C} callback - The `callback` parameter is a function that will be called on each node in
-     * the tree. It takes a node as input and returns a value. The return type of the callback function
-     * is determined by the generic type `C`.
-     * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
-     * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
-     * from the root node of the binary tree.
-     * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
-     * recursively or iteratively. It can have two possible values:
-     * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
-     * 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<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[][];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    subTreeTraverse<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: BTNKey | N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * The function returns the predecessor node of a given node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree.

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

@@ -703,9 +703,10 @@ class BinaryTree {
      * start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
      * performed on the binary tree. It can have two possible values:
+     * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
      */
-    subTreeTraverse(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    subTreeTraverse(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         if (typeof beginRoot === 'number')
             beginRoot = this.getNode(beginRoot);
         const ans = [];
@@ -713,9 +714,17 @@ class BinaryTree {
             return ans;
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                ans.push(callback(cur));
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                if (cur !== undefined) {
+                    ans.push(callback(cur));
+                    if (includeNull) {
+                        cur !== null && cur.left !== undefined && _traverse(cur.left);
+                        cur !== null && cur.right !== undefined && _traverse(cur.right);
+                    }
+                    else {
+                        cur !== null && cur.left && _traverse(cur.left);
+                        cur !== null && cur.right && _traverse(cur.right);
+                    }
+                }
             };
             _traverse(beginRoot);
         }
@@ -723,9 +732,17 @@ class BinaryTree {
             const stack = [beginRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                ans.push(callback(cur));
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
+                if (cur !== undefined) {
+                    ans.push(callback(cur));
+                    if (includeNull) {
+                        cur !== null && cur.right !== undefined && stack.push(cur.right);
+                        cur !== null && cur.left !== undefined && stack.push(cur.left);
+                    }
+                    else {
+                        cur !== null && cur.right && stack.push(cur.right);
+                        cur !== null && cur.left && stack.push(cur.left);
+                    }
+                }
             }
         }
         return ans;
@@ -743,9 +760,10 @@ class BinaryTree {
      * is `null`, an empty array will be returned.
      * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
      * iteration used in the depth-first search algorithm. It can have two possible values:
+     * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
      */
-    dfs(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
+    dfs(callback = this.defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE, includeNull = false) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -753,25 +771,52 @@ class BinaryTree {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
-                        if (node.left)
-                            _traverse(node.left);
-                        ans.push(callback(node));
-                        if (node.right)
-                            _traverse(node.right);
+                        if (includeNull) {
+                            if (node !== null && node.left !== undefined)
+                                _traverse(node.left);
+                            ans.push(callback(node));
+                            if (node !== null && node.right !== undefined)
+                                _traverse(node.right);
+                        }
+                        else {
+                            if (node !== null && node.left)
+                                _traverse(node.left);
+                            ans.push(callback(node));
+                            if (node !== null && node.right)
+                                _traverse(node.right);
+                        }
                         break;
                     case 'pre':
-                        ans.push(callback(node));
-                        if (node.left)
-                            _traverse(node.left);
-                        if (node.right)
-                            _traverse(node.right);
+                        if (includeNull) {
+                            ans.push(callback(node));
+                            if (node !== null && node.left !== undefined)
+                                _traverse(node.left);
+                            if (node !== null && node.right !== undefined)
+                                _traverse(node.right);
+                        }
+                        else {
+                            ans.push(callback(node));
+                            if (node !== null && node.left)
+                                _traverse(node.left);
+                            if (node !== null && node.right)
+                                _traverse(node.right);
+                        }
                         break;
                     case 'post':
-                        if (node.left)
-                            _traverse(node.left);
-                        if (node.right)
-                            _traverse(node.right);
-                        ans.push(callback(node));
+                        if (includeNull) {
+                            if (node !== null && node.left !== undefined)
+                                _traverse(node.left);
+                            if (node !== null && node.right !== undefined)
+                                _traverse(node.right);
+                            ans.push(callback(node));
+                        }
+                        else {
+                            if (node !== null && node.left)
+                                _traverse(node.left);
+                            if (node !== null && node.right)
+                                _traverse(node.right);
+                            ans.push(callback(node));
+                        }
                         break;
                 }
             };
@@ -782,32 +827,40 @@ class BinaryTree {
             const stack = [{ opt: 0, node: beginRoot }];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                if (!cur || !cur.node)
+                if (cur === undefined)
                     continue;
+                if (includeNull) {
+                    if (cur.node === undefined)
+                        continue;
+                }
+                else {
+                    if (cur.node === null || cur.node === undefined)
+                        continue;
+                }
                 if (cur.opt === 1) {
                     ans.push(callback(cur.node));
                 }
                 else {
                     switch (pattern) {
                         case 'in':
-                            stack.push({ opt: 0, node: cur.node.right });
+                            cur.node && stack.push({ opt: 0, node: cur.node.right });
                             stack.push({ opt: 1, node: cur.node });
-                            stack.push({ opt: 0, node: cur.node.left });
+                            cur.node && stack.push({ opt: 0, node: cur.node.left });
                             break;
                         case 'pre':
-                            stack.push({ opt: 0, node: cur.node.right });
-                            stack.push({ opt: 0, node: cur.node.left });
+                            cur.node && stack.push({ opt: 0, node: cur.node.right });
+                            cur.node && stack.push({ opt: 0, node: cur.node.left });
                             stack.push({ opt: 1, node: cur.node });
                             break;
                         case 'post':
                             stack.push({ opt: 1, node: cur.node });
-                            stack.push({ opt: 0, node: cur.node.right });
-                            stack.push({ opt: 0, node: cur.node.left });
+                            cur.node && stack.push({ opt: 0, node: cur.node.right });
+                            cur.node && stack.push({ opt: 0, node: cur.node.left });
                             break;
                         default:
-                            stack.push({ opt: 0, node: cur.node.right });
+                            cur.node && stack.push({ opt: 0, node: cur.node.right });
                             stack.push({ opt: 1, node: cur.node });
-                            stack.push({ opt: 0, node: cur.node.left });
+                            cur.node && stack.push({ opt: 0, node: cur.node.left });
                             break;
                     }
                 }
@@ -826,9 +879,10 @@ class BinaryTree {
      * will not be performed and an empty array will be returned.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
+     * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
      */
-    bfs(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         if (!beginRoot)
             return [];
         const ans = [];
@@ -839,10 +893,18 @@ class BinaryTree {
                     return;
                 const current = queue.shift();
                 ans.push(callback(current));
-                if (current.left)
-                    queue.push(current.left);
-                if (current.right)
-                    queue.push(current.right);
+                if (includeNull) {
+                    if (current && current.left !== undefined)
+                        queue.push(current.left);
+                    if (current && current.right !== undefined)
+                        queue.push(current.right);
+                }
+                else {
+                    if (current.left)
+                        queue.push(current.left);
+                    if (current.right)
+                        queue.push(current.right);
+                }
                 traverse(level + 1);
             };
             traverse(0);
@@ -854,10 +916,18 @@ class BinaryTree {
                 for (let i = 0; i < levelSize; i++) {
                     const current = queue.shift();
                     ans.push(callback(current));
-                    if (current.left)
-                        queue.push(current.left);
-                    if (current.right)
-                        queue.push(current.right);
+                    if (includeNull) {
+                        if (current !== null && current.left !== undefined)
+                            queue.push(current.left);
+                        if (current !== null && current.right !== undefined)
+                            queue.push(current.right);
+                    }
+                    else {
+                        if (current.left)
+                            queue.push(current.left);
+                        if (current.right)
+                            queue.push(current.right);
+                    }
                 }
             }
         }
@@ -874,11 +944,12 @@ class BinaryTree {
      * from the root node of the binary tree.
      * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
      * recursively or iteratively. It can have two possible values:
+     * @param includeNull - The choice to output null values during binary tree traversal should be provided.
      * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
      * 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.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+    listLevels(callback = this.defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         if (!beginRoot)
             return [];
         const levelsNodes = [];
@@ -887,10 +958,18 @@ class BinaryTree {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
                 levelsNodes[level].push(callback(node));
-                if (node.left)
-                    _recursive(node.left, level + 1);
-                if (node.right)
-                    _recursive(node.right, level + 1);
+                if (includeNull) {
+                    if (node && node.left !== undefined)
+                        _recursive(node.left, level + 1);
+                    if (node && node.right !== undefined)
+                        _recursive(node.right, level + 1);
+                }
+                else {
+                    if (node && node.left)
+                        _recursive(node.left, level + 1);
+                    if (node && node.right)
+                        _recursive(node.right, level + 1);
+                }
             };
             _recursive(beginRoot, 0);
         }
@@ -902,10 +981,18 @@ class BinaryTree {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
                 levelsNodes[level].push(callback(node));
-                if (node.right)
-                    stack.push([node.right, level + 1]);
-                if (node.left)
-                    stack.push([node.left, level + 1]);
+                if (includeNull) {
+                    if (node && node.right !== undefined)
+                        stack.push([node.right, level + 1]);
+                    if (node && node.left !== undefined)
+                        stack.push([node.left, level + 1]);
+                }
+                else {
+                    if (node && node.right)
+                        stack.push([node.right, level + 1]);
+                    if (node && node.left)
+                        stack.push([node.left, level + 1]);
+                }
             }
         }
         return levelsNodes;

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -114,9 +114,10 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * It is the starting vertex for finding paths.
      * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param limit - The count of limitation of result array.
      * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
      */
-    getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey): VO[][];
+    getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey, limit?: number): VO[][];
     /**
      * The function calculates the sum of weights along a given path.
      * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -148,10 +149,13 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
      * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
      * to false, the function will use breadth-first search (BFS) to find the minimum path.
+     * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+     * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+     * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
      * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
      */
-    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): VO[] | null;
+    getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS?: boolean): VO[] | null;
     /**
      * Dijkstra algorithm time: O(VE) space: O(VO + EO)
      * /

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

@@ -4,8 +4,8 @@ exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 /**
  * data-structure-typed
  *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 const utils_1 = require("../../utils");
@@ -162,31 +162,33 @@ class AbstractGraph {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * It is the starting vertex for finding paths.
      * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param limit - The count of limitation of result array.
      * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
      */
-    getAllPathsBetween(v1, v2) {
+    getAllPathsBetween(v1, v2, limit = 1000) {
         const paths = [];
         const vertex1 = this._getVertex(v1);
         const vertex2 = this._getVertex(v2);
         if (!(vertex1 && vertex2)) {
             return [];
         }
-        const dfs = (cur, dest, visiting, path) => {
-            visiting.add(cur);
-            if (cur === dest) {
-                paths.push([vertex1, ...path]);
+        const stack = [];
+        stack.push({ vertex: vertex1, path: [vertex1] });
+        while (stack.length > 0) {
+            const { vertex, path } = stack.pop();
+            if (vertex === vertex2) {
+                paths.push(path);
+                if (paths.length >= limit)
+                    return paths;
             }
-            const neighbors = this.getNeighbors(cur);
+            const neighbors = this.getNeighbors(vertex);
             for (const neighbor of neighbors) {
-                if (!visiting.has(neighbor)) {
-                    path.push(neighbor);
-                    dfs(neighbor, dest, visiting, path);
-                    path.pop();
+                if (!path.includes(neighbor)) {
+                    const newPath = [...path, neighbor];
+                    stack.push({ vertex: neighbor, path: newPath });
                 }
             }
-            visiting.delete(cur);
-        };
-        dfs(vertex1, vertex2, new Set(), []);
+        }
         return paths;
     }
     /**
@@ -270,52 +272,60 @@ class AbstractGraph {
      * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
      * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
      * to false, the function will use breadth-first search (BFS) to find the minimum path.
+     * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+     * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+     * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
      * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
      * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
      */
-    getMinPathBetween(v1, v2, isWeight) {
+    getMinPathBetween(v1, v2, isWeight, isDFS = false) {
+        var _a, _b;
         if (isWeight === undefined)
             isWeight = false;
         if (isWeight) {
-            const allPaths = this.getAllPathsBetween(v1, v2);
-            let min = Infinity;
-            let minIndex = -1;
-            let index = 0;
-            for (const path of allPaths) {
-                const pathSumWeight = this.getPathSumWeight(path);
-                if (pathSumWeight < min) {
-                    min = pathSumWeight;
-                    minIndex = index;
+            if (isDFS) {
+                const allPaths = this.getAllPathsBetween(v1, v2, 10000);
+                let min = Infinity;
+                let minIndex = -1;
+                let index = 0;
+                for (const path of allPaths) {
+                    const pathSumWeight = this.getPathSumWeight(path);
+                    if (pathSumWeight < min) {
+                        min = pathSumWeight;
+                        minIndex = index;
+                    }
+                    index++;
                 }
-                index++;
+                return allPaths[minIndex] || null;
+            }
+            else {
+                return (_b = (_a = this.dijkstra(v1, v2, true, true)) === null || _a === void 0 ? void 0 : _a.minPath) !== null && _b !== void 0 ? _b : [];
             }
-            return allPaths[minIndex] || null;
         }
         else {
-            // BFS
+            // DFS
             let minPath = [];
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
-            if (!(vertex1 && vertex2)) {
+            if (!(vertex1 && vertex2))
                 return [];
-            }
             const dfs = (cur, dest, visiting, path) => {
-                visiting.set(cur, true);
+                visiting.add(cur);
                 if (cur === dest) {
                     minPath = [vertex1, ...path];
                     return;
                 }
                 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 minPath;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.41.8",
+  "version": "1.42.0",
   "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.8"
+    "data-structure-typed": "^1.42.0"
   }
 }

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

@@ -108,8 +108,7 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -391,7 +390,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
+      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -846,6 +845,27 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.isSubtreeBST(this.root, iterationType);
   }
 
+  subTreeTraverse<C extends BTNCallback<N>>(
+    callback?: C,
+    beginRoot?: BTNKey | N | null,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[]
+
+  subTreeTraverse<C extends BTNCallback<N>>(
+    callback?: C,
+    beginRoot?: BTNKey | N | null,
+    iterationType?: IterationType,
+    includeNull?: undefined
+  ): ReturnType<C>[]
+
+  subTreeTraverse<C extends BTNCallback<N | null>>(
+    callback?: C,
+    beginRoot?: BTNKey | N | null,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[]
+
   /**
    * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
    * node, either recursively or iteratively.
@@ -858,40 +878,79 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * start from the root of the tree.
    * @param iterationType - The `iterationType` parameter determines the type of traversal to be
    * performed on the binary tree. It can have two possible values:
+   * @param includeNull - The choice to output null values during binary tree traversal should be provided.
    * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
-  subTreeTraverse<C extends BTNCallback<N>>(
+  subTreeTraverse<C extends BTNCallback<N | null>>(
     callback: C = this.defaultOneParamCallback as C,
     beginRoot: BTNKey | N | null = this.root,
-    iterationType = this.iterationType
+    iterationType = this.iterationType,
+    includeNull = false
   ): ReturnType<C>[] {
     if (typeof beginRoot === 'number') beginRoot = this.getNode(beginRoot);
 
-    const ans: ReturnType<BTNCallback<N>>[] = [];
+    const ans: (ReturnType<BTNCallback<N>> | null)[] = [];
     if (!beginRoot) return ans;
 
     if (iterationType === IterationType.RECURSIVE) {
-      const _traverse = (cur: N) => {
-        ans.push(callback(cur));
-        cur.left && _traverse(cur.left);
-        cur.right && _traverse(cur.right);
+      const _traverse = (cur: N | null) => {
+        if (cur !== undefined) {
+          ans.push(callback(cur));
+          if (includeNull) {
+            cur !== null && cur.left !== undefined && _traverse(cur.left);
+            cur !== null && cur.right !== undefined && _traverse(cur.right);
+          } else {
+            cur !== null && cur.left && _traverse(cur.left);
+            cur !== null && cur.right && _traverse(cur.right);
+          }
+        }
       };
 
       _traverse(beginRoot);
     } else {
-      const stack: N[] = [beginRoot];
+      const stack: (N| null)[] = [beginRoot];
 
       while (stack.length > 0) {
-        const cur = stack.pop()!;
-
-        ans.push(callback(cur));
-        cur.right && stack.push(cur.right);
-        cur.left && stack.push(cur.left);
+        const cur = stack.pop();
+        if (cur !== undefined) {
+          ans.push(callback(cur));
+          if (includeNull) {
+            cur !== null && cur.right !== undefined && stack.push(cur.right);
+            cur !== null && cur.left !== undefined && stack.push(cur.left);
+          } else {
+            cur !== null && cur.right && stack.push(cur.right);
+            cur !== null && cur.left && stack.push(cur.left);
+          }
+        }
       }
     }
     return ans;
   }
 
+  dfs<C extends BTNCallback<N>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[]
+
+  dfs<C extends BTNCallback<N>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: undefined
+  ): ReturnType<C>[]
+
+  dfs<C extends BTNCallback<N | null>>(
+    callback?: C,
+    pattern?: DFSOrderPattern,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[]
+
   /**
    * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
    * function on each node according to a specified order pattern.
@@ -905,34 +964,53 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * is `null`, an empty array will be returned.
    * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
    * iteration used in the depth-first search algorithm. It can have two possible values:
+   * @param includeNull - The choice to output null values during binary tree traversal should be provided.
    * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
    */
-  dfs<C extends BTNCallback<N>>(
+  dfs<C extends BTNCallback<N | null>>(
     callback: C = this.defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
-    iterationType: IterationType = IterationType.ITERATIVE
+    iterationType: IterationType = IterationType.ITERATIVE,
+    includeNull = false
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
-    const ans: ReturnType<BTNCallback<N>>[] = [];
+    const ans: ReturnType<C>[] = [];
     if (iterationType === IterationType.RECURSIVE) {
-      const _traverse = (node: N) => {
+      const _traverse = (node: N | null) => {
         switch (pattern) {
           case 'in':
-            if (node.left) _traverse(node.left);
-            ans.push(callback(node));
-            if (node.right) _traverse(node.right);
+            if (includeNull) {
+              if (node !== null && node.left !== undefined) _traverse(node.left);
+              ans.push(callback(node));
+              if (node !== null && node.right !== undefined) _traverse(node.right);
+            } else {
+              if (node !== null && node.left) _traverse(node.left);
+              ans.push(callback(node));
+              if (node !== null && node.right) _traverse(node.right);
+            }
             break;
           case 'pre':
-            ans.push(callback(node));
-
-            if (node.left) _traverse(node.left);
-            if (node.right) _traverse(node.right);
+            if (includeNull) {
+              ans.push(callback(node));
+              if (node !== null && node.left !== undefined) _traverse(node.left);
+              if (node !== null && node.right !== undefined) _traverse(node.right);
+            } else {
+              ans.push(callback(node));
+              if (node !== null && node.left) _traverse(node.left);
+              if (node !== null && node.right) _traverse(node.right);
+            }
             break;
           case 'post':
-            if (node.left) _traverse(node.left);
-            if (node.right) _traverse(node.right);
-            ans.push(callback(node));
+            if (includeNull) {
+              if (node !== null && node.left !== undefined) _traverse(node.left);
+              if (node !== null && node.right !== undefined) _traverse(node.right);
+              ans.push(callback(node));
+            } else {
+              if (node !== null && node.left) _traverse(node.left);
+              if (node !== null && node.right) _traverse(node.right);
+              ans.push(callback(node));
+            }
 
             break;
         }
@@ -941,34 +1019,39 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
+      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
-        if (!cur || !cur.node) continue;
+        if (cur === undefined) continue;
+        if (includeNull) {
+          if (cur.node === undefined) continue;
+        } else {
+          if (cur.node === null || cur.node === undefined) continue;
+        }
         if (cur.opt === 1) {
           ans.push(callback(cur.node));
         } else {
           switch (pattern) {
             case 'in':
-              stack.push({opt: 0, node: cur.node.right});
+              cur.node && stack.push({opt: 0, node: cur.node.right});
               stack.push({opt: 1, node: cur.node});
-              stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({opt: 0, node: cur.node.left});
               break;
             case 'pre':
-              stack.push({opt: 0, node: cur.node.right});
-              stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({opt: 0, node: cur.node.right});
+              cur.node && stack.push({opt: 0, node: cur.node.left});
               stack.push({opt: 1, node: cur.node});
               break;
             case 'post':
               stack.push({opt: 1, node: cur.node});
-              stack.push({opt: 0, node: cur.node.right});
-              stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({opt: 0, node: cur.node.right});
+              cur.node && stack.push({opt: 0, node: cur.node.left});
               break;
             default:
-              stack.push({opt: 0, node: cur.node.right});
+              cur.node && stack.push({opt: 0, node: cur.node.right});
               stack.push({opt: 1, node: cur.node});
-              stack.push({opt: 0, node: cur.node.left});
+              cur.node && stack.push({opt: 0, node: cur.node.left});
               break;
           }
         }
@@ -978,6 +1061,27 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
+  bfs<C extends BTNCallback<N>>(
+    callback?: C,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[]
+
+  bfs<C extends BTNCallback<N>>(
+    callback?: C,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: undefined
+  ): ReturnType<C>[]
+
+  bfs<C extends BTNCallback<N | null>>(
+    callback?: C,
+    beginRoot?: N | null,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[]
+
   /**
    * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
    * function on each node.
@@ -989,19 +1093,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * will not be performed and an empty array will be returned.
    * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
    * in the breadth-first search (BFS) algorithm. It can have two possible values:
+   * @param includeNull - The choice to output null values during binary tree traversal should be provided.
    * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
    */
-  bfs<C extends BTNCallback<N>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback: C = this.defaultOneParamCallback as C,
     beginRoot: N | null = this.root,
-    iterationType = this.iterationType
+    iterationType = this.iterationType,
+    includeNull = false
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
 
     const ans: ReturnType<BTNCallback<N>>[] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
-      const queue = new Queue<N>([beginRoot]);
+      const queue: Queue<N | null> = new Queue<N | null>([beginRoot]);
 
       const traverse = (level: number) => {
         if (queue.size === 0) return;
@@ -1009,15 +1115,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         const current = queue.shift()!;
         ans.push(callback(current));
 
-        if (current.left) queue.push(current.left);
-        if (current.right) queue.push(current.right);
+        if (includeNull) {
+          if (current && current.left !== undefined) queue.push(current.left);
+          if (current && current.right !== undefined) queue.push(current.right);
+        } else {
+          if (current.left) queue.push(current.left);
+          if (current.right) queue.push(current.right);
+        }
+
 
         traverse(level + 1);
       };
 
       traverse(0);
     } else {
-      const queue = new Queue<N>([beginRoot]);
+      const queue = new Queue<N | null>([beginRoot]);
       while (queue.size > 0) {
         const levelSize = queue.size;
 
@@ -1025,14 +1137,41 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           const current = queue.shift()!;
           ans.push(callback(current));
 
-          if (current.left) queue.push(current.left);
-          if (current.right) queue.push(current.right);
+          if (includeNull) {
+            if (current !== null && current.left !== undefined) queue.push(current.left);
+            if (current !== null && current.right !== undefined) queue.push(current.right);
+          } else {
+            if (current.left) queue.push(current.left);
+            if (current.right) queue.push(current.right);
+          }
+
         }
       }
     }
     return ans;
   }
 
+  listLevels<C extends BTNCallback<N>>(
+    callback?: C ,
+    beginRoot?: N | null ,
+    iterationType?: IterationType,
+    includeNull?: false
+  ): ReturnType<C>[][]
+
+  listLevels<C extends BTNCallback<N>>(
+    callback?: C ,
+    beginRoot?: N | null ,
+    iterationType?: IterationType,
+    includeNull?: undefined
+  ): ReturnType<C>[][]
+
+  listLevels<C extends BTNCallback<N | null>>(
+    callback?: C ,
+    beginRoot?: N | null ,
+    iterationType?: IterationType,
+    includeNull?: true
+  ): ReturnType<C>[][]
+
   /**
    * The `listLevels` function takes a binary tree node and a callback function, and returns an array
    * of arrays representing the levels of the tree.
@@ -1044,29 +1183,36 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * from the root node of the binary tree.
    * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
    * recursively or iteratively. It can have two possible values:
+   * @param includeNull - The choice to output null values during binary tree traversal should be provided.
    * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
    * 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<C extends BTNCallback<N>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback: C = this.defaultOneParamCallback as C,
     beginRoot: N | null = this.root,
-    iterationType = this.iterationType
+    iterationType = this.iterationType,
+    includeNull = false
   ): ReturnType<C>[][] {
     if (!beginRoot) return [];
     const levelsNodes: ReturnType<C>[][] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
-      const _recursive = (node: N, level: number) => {
+      const _recursive = (node: N | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
-        if (node.left) _recursive(node.left, level + 1);
-        if (node.right) _recursive(node.right, level + 1);
+        if (includeNull) {
+          if (node && node.left !== undefined) _recursive(node.left, level + 1);
+          if (node && node.right !== undefined) _recursive(node.right, level + 1);
+        } else  {
+          if (node && node.left) _recursive(node.left, level + 1);
+          if (node && node.right) _recursive(node.right, level + 1);
+        }
       };
 
       _recursive(beginRoot, 0);
     } else {
-      const stack: [N, number][] = [[beginRoot, 0]];
+      const stack: [N | null, number][] = [[beginRoot, 0]];
 
       while (stack.length > 0) {
         const head = stack.pop()!;
@@ -1074,8 +1220,14 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
-        if (node.right) stack.push([node.right, level + 1]);
-        if (node.left) stack.push([node.left, level + 1]);
+
+        if (includeNull) {
+          if (node && node.right !== undefined) stack.push([node.right, level + 1]);
+          if (node && node.left !== undefined) stack.push([node.left, level + 1]);
+        } else  {
+          if (node && node.right) stack.push([node.right, level + 1]);
+          if (node && node.left) stack.push([node.left, level + 1]);
+        }
       }
     }
 
@@ -1231,7 +1383,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }

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

@@ -1,11 +1,11 @@
 /**
  * data-structure-typed
  *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import {arrayRemove, uuidV4} from '../../utils';
+import {uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, VertexKey} from '../../types';
 import {IGraph} from '../../interfaces';
@@ -223,39 +223,43 @@ export abstract class AbstractGraph<
    * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
    * It is the starting vertex for finding paths.
    * @param {VO | VertexKey} v2 - The parameter `v2` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+   * @param limit - The count of limitation of result array.
    * @returns The function `getAllPathsBetween` returns an array of arrays of vertices (`VO[][]`).
    */
-  getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey): VO[][] {
+  getAllPathsBetween(v1: VO | VertexKey, v2: VO | VertexKey, limit = 1000): VO[][] {
     const paths: VO[][] = [];
     const vertex1 = this._getVertex(v1);
     const vertex2 = this._getVertex(v2);
+
     if (!(vertex1 && vertex2)) {
       return [];
     }
 
-    const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
-      visiting.add(cur);
+    const stack: { vertex: VO, path: VO[] }[] = [];
+    stack.push({ vertex: vertex1, path: [vertex1] });
+
+    while (stack.length > 0) {
+      const { vertex, path } = stack.pop()!;
 
-      if (cur === dest) {
-        paths.push([vertex1, ...path]);
+      if (vertex === vertex2) {
+        paths.push(path);
+        if (paths.length >= limit) return paths;
       }
 
-      const neighbors = this.getNeighbors(cur);
+      const neighbors = this.getNeighbors(vertex);
       for (const neighbor of neighbors) {
-        if (!visiting.has(neighbor)) {
-          path.push(neighbor);
-          dfs(neighbor, dest, visiting, path);
-          path.pop();
+        if (!path.includes(neighbor)) {
+          const newPath = [...path, neighbor];
+          stack.push({ vertex: neighbor, path: newPath });
         }
       }
-
-      visiting.delete(cur);
-    };
-
-    dfs(vertex1, vertex2, new Set<VO>(), []);
+    }
     return paths;
   }
 
+
+
+
   /**
    * The function calculates the sum of weights along a given path.
    * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -338,38 +342,43 @@ export abstract class AbstractGraph<
    * @param {boolean} [isWeight] - A boolean flag indicating whether to consider the weight of edges in finding the
    * minimum path. If set to true, the function will use Dijkstra's algorithm to find the minimum weighted path. If set
    * to false, the function will use breadth-first search (BFS) to find the minimum path.
+   * @param isDFS - If set to true, it enforces the use of getAllPathsBetween to first obtain all possible paths,
+   * followed by iterative computation of the shortest path. This approach may result in exponential time complexity,
+   * so the default method is to use the Dijkstra algorithm to obtain the shortest weighted path.
    * @returns The function `getMinPathBetween` returns an array of vertices (`VO[]`) representing the minimum path between
    * two vertices (`v1` and `v2`). If there is no path between the vertices, it returns `null`.
    */
-  getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean): VO[] | null {
+  getMinPathBetween(v1: VO | VertexKey, v2: VO | VertexKey, isWeight?: boolean, isDFS = false): VO[] | null {
     if (isWeight === undefined) isWeight = false;
 
     if (isWeight) {
-      const allPaths = this.getAllPathsBetween(v1, v2);
-      let min = Infinity;
-      let minIndex = -1;
-      let index = 0;
-      for (const path of allPaths) {
-        const pathSumWeight = this.getPathSumWeight(path);
-        if (pathSumWeight < min) {
-          min = pathSumWeight;
-          minIndex = index;
+      if (isDFS) {
+        const allPaths = this.getAllPathsBetween(v1, v2, 10000);
+        let min = Infinity;
+        let minIndex = -1;
+        let index = 0;
+        for (const path of allPaths) {
+          const pathSumWeight = this.getPathSumWeight(path);
+          if (pathSumWeight < min) {
+            min = pathSumWeight;
+            minIndex = index;
+          }
+          index++;
         }
-        index++;
+        return allPaths[minIndex] || null;
+      } else {
+        return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
-      return allPaths[minIndex] || null;
+
     } else {
-      // BFS
+      // DFS
       let minPath: VO[] = [];
       const vertex1 = this._getVertex(v1);
       const vertex2 = this._getVertex(v2);
-      if (!(vertex1 && vertex2)) {
-        return [];
-      }
-
-      const dfs = (cur: VO, dest: VO, visiting: Map<VO, boolean>, path: VO[]) => {
-        visiting.set(cur, true);
+      if (!(vertex1 && vertex2)) return [];
 
+      const dfs = (cur: VO, dest: VO, visiting: Set<VO>, path: VO[]) => {
+        visiting.add(cur);
         if (cur === dest) {
           minPath = [vertex1, ...path];
           return;
@@ -377,17 +386,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 minPath;
     }
   }