min-heap-typed 1.42.1 → 1.42.3

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

@@ -79,7 +79,6 @@ 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.
@@ -289,6 +288,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * binary tree nodes in a specific order.
      */
     [Symbol.iterator](node?: N | null): Generator<BTNKey, void, undefined>;
+    protected defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.

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

@@ -1034,7 +1034,6 @@ class BinaryTree {
         }
         return y;
     }
-    // --- start additional methods ---
     /**
      * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
      * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -1133,6 +1132,7 @@ class BinaryTree {
         }
         return ans;
     }
+    // --- start additional methods ---
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.

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

@@ -252,10 +252,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
      * all pairs
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
-    /**
-     * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
-     * all pairs
      * /
   
      /**
@@ -264,12 +260,12 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
      * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
      * graph.
-     * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
      * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
-    floyd(): {
+    floydWarshall(): {
         costs: number[][];
         predecessor: (VO | null)[][];
     };
@@ -289,7 +285,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
      * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
      * strongly connected components (SCCs), and cycles in a graph.
-     * @param {boolean} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+     * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
      * articulation points in the graph. Articulation points are the vertices in a graph whose removal would increase the
      * number of connected components in the graph.
      * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
@@ -302,14 +298,48 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * are arrays of vertices that form cycles within the SCCs.
      * @returns The function `tarjan` returns an object with the following properties:
      */
-    tarjan(needArticulationPoints?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
+    tarjan(needCutVertexes?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
         dfnMap: Map<VO, number>;
         lowMap: Map<VO, number>;
         bridges: EO[];
-        articulationPoints: VO[];
+        cutVertexes: VO[];
         SCCs: Map<number, VO[]>;
         cycles: Map<number, VO[]>;
     };
+    /**
+     * The function returns a map that associates each vertex object with its corresponding depth-first
+     * number.
+     * @returns A Map object with keys of type VO and values of type number.
+     */
+    getDFNMap(): Map<VO, number>;
+    /**
+     * The function returns a Map object that contains the low values of each vertex in a Tarjan
+     * algorithm.
+     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
+     * type `number`.
+     */
+    getLowMap(): Map<VO, number>;
+    /**
+     * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
+     * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
+     */
+    getCycles(): Map<number, VO[]>;
+    /**
+     * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
+     * @returns an array of VO objects, specifically the cut vertexes.
+     */
+    getCutVertexes(): VO[];
+    /**
+     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
+     * algorithm.
+     * @returns a map where the keys are numbers and the values are arrays of VO objects.
+     */
+    getSCCs(): Map<number, VO[]>;
+    /**
+     * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
+     * @returns the bridges found using the Tarjan algorithm.
+     */
+    getBridges(): EO[];
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | null;

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

@@ -704,10 +704,6 @@ class AbstractGraph {
      * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
      * all pairs
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
-    /**
-     * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
-     * all pairs
      * /
   
      /**
@@ -716,12 +712,12 @@ class AbstractGraph {
      * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
      * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
      * graph.
-     * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+     * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
      * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
      * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
      * path between vertices in the
      */
-    floyd() {
+    floydWarshall() {
         var _a;
         const idAndVertices = [...this._vertices];
         const n = idAndVertices.length;
@@ -768,7 +764,7 @@ class AbstractGraph {
      * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
      * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
      * strongly connected components (SCCs), and cycles in a graph.
-     * @param {boolean} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+     * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
      * articulation points in the graph. Articulation points are the vertices in a graph whose removal would increase the
      * number of connected components in the graph.
      * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
@@ -781,13 +777,13 @@ class AbstractGraph {
      * are arrays of vertices that form cycles within the SCCs.
      * @returns The function `tarjan` returns an object with the following properties:
      */
-    tarjan(needArticulationPoints, needBridges, needSCCs, needCycles) {
+    tarjan(needCutVertexes = false, needBridges = false, needSCCs = true, needCycles = false) {
         // !! in undirected graph we will not let child visit parent when dfs
         // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
         // !! bridge: low(child) > dfn(cur)
         const defaultConfig = false;
-        if (needArticulationPoints === undefined)
-            needArticulationPoints = defaultConfig;
+        if (needCutVertexes === undefined)
+            needCutVertexes = defaultConfig;
         if (needBridges === undefined)
             needBridges = defaultConfig;
         if (needSCCs === undefined)
@@ -802,7 +798,7 @@ class AbstractGraph {
             lowMap.set(v, Infinity);
         });
         const [root] = vertices.values();
-        const articulationPoints = [];
+        const cutVertexes = [];
         const bridges = [];
         let dfn = 0;
         const dfs = (cur, parent) => {
@@ -825,10 +821,10 @@ class AbstractGraph {
                     }
                     const curFromMap = dfnMap.get(cur);
                     if (childLow !== undefined && curFromMap !== undefined) {
-                        if (needArticulationPoints) {
+                        if (needCutVertexes) {
                             if ((cur === root && childCount >= 2) || (cur !== root && childLow >= curFromMap)) {
                                 // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
-                                articulationPoints.push(cur);
+                                cutVertexes.push(cur);
                             }
                         }
                         if (needBridges) {
@@ -873,7 +869,53 @@ class AbstractGraph {
                 }
             });
         }
-        return { dfnMap, lowMap, bridges, articulationPoints, SCCs, cycles };
+        return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
+    }
+    /**
+     * The function returns a map that associates each vertex object with its corresponding depth-first
+     * number.
+     * @returns A Map object with keys of type VO and values of type number.
+     */
+    getDFNMap() {
+        return this.tarjan(false, false, false, false).dfnMap;
+    }
+    /**
+     * The function returns a Map object that contains the low values of each vertex in a Tarjan
+     * algorithm.
+     * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
+     * type `number`.
+     */
+    getLowMap() {
+        return this.tarjan(false, false, false, false).lowMap;
+    }
+    /**
+     * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
+     * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
+     */
+    getCycles() {
+        return this.tarjan(false, false, false, true).cycles;
+    }
+    /**
+     * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
+     * @returns an array of VO objects, specifically the cut vertexes.
+     */
+    getCutVertexes() {
+        return this.tarjan(true, false, false, false).cutVertexes;
+    }
+    /**
+     * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
+     * algorithm.
+     * @returns a map where the keys are numbers and the values are arrays of VO objects.
+     */
+    getSCCs() {
+        return this.tarjan(false, false, true, false).SCCs;
+    }
+    /**
+     * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
+     * @returns the bridges found using the Tarjan algorithm.
+     */
+    getBridges() {
+        return this.tarjan(false, true, false, false).bridges;
     }
     _addVertexOnly(newVertex) {
         if (this.hasVertex(newVertex)) {

package/package.json

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

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

@@ -108,7 +108,8 @@ 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;
 
   /**
@@ -140,8 +141,6 @@ 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.
@@ -390,7 +389,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) {
@@ -850,21 +849,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N>>(
     callback?: C,
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
@@ -908,7 +907,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
       _traverse(beginRoot);
     } else {
-      const stack: (N| null)[] = [beginRoot];
+      const stack: (N | null)[] = [beginRoot];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -933,7 +932,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   dfs<C extends BTNCallback<N>>(
     callback?: C,
@@ -941,7 +940,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   dfs<C extends BTNCallback<N | null>>(
     callback?: C,
@@ -949,7 +948,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
@@ -1019,7 +1018,7 @@ 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();
@@ -1066,21 +1065,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N>>(
     callback?: C,
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
@@ -1123,7 +1122,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           if (current.right) queue.push(current.right);
         }
 
-
         traverse(level + 1);
       };
 
@@ -1144,7 +1142,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
             if (current.left) queue.push(current.left);
             if (current.right) queue.push(current.right);
           }
-
         }
       }
     }
@@ -1152,25 +1149,25 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   }
 
   listLevels<C extends BTNCallback<N>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N | null>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   /**
    * The `listLevels` function takes a binary tree node and a callback function, and returns an array
@@ -1204,7 +1201,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         if (includeNull) {
           if (node && node.left !== undefined) _recursive(node.left, level + 1);
           if (node && node.right !== undefined) _recursive(node.right, level + 1);
-        } else  {
+        } else {
           if (node && node.left) _recursive(node.left, level + 1);
           if (node && node.right) _recursive(node.right, level + 1);
         }
@@ -1224,7 +1221,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         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  {
+        } else {
           if (node && node.right) stack.push([node.right, level + 1]);
           if (node && node.left) stack.push([node.left, level + 1]);
         }
@@ -1273,8 +1270,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return y;
   }
 
-  // --- start additional methods ---
-
   /**
    * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
    * algorithm and returns an array of values obtained by applying a callback function to each node.
@@ -1374,6 +1369,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
+  // --- start additional methods ---
+
   /**
    * The above function is an iterator for a binary tree that can be used to traverse the tree in
    * either an iterative or recursive manner.
@@ -1383,7 +1380,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;
     }
@@ -1416,6 +1413,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
   }
 
+  protected defaultOneParamCallback = (node: N) => node.key;
+
   /**
    * Swap the data of two nodes in the binary tree.
    * @param {N} srcNode - The source node to swap.

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

@@ -235,11 +235,11 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const stack: { vertex: VO, path: VO[] }[] = [];
-    stack.push({ vertex: vertex1, path: [vertex1] });
+    const stack: {vertex: VO; path: VO[]}[] = [];
+    stack.push({vertex: vertex1, path: [vertex1]});
 
     while (stack.length > 0) {
-      const { vertex, path } = stack.pop()!;
+      const {vertex, path} = stack.pop()!;
 
       if (vertex === vertex2) {
         paths.push(path);
@@ -250,16 +250,13 @@ export abstract class AbstractGraph<
       for (const neighbor of neighbors) {
         if (!path.includes(neighbor)) {
           const newPath = [...path, neighbor];
-          stack.push({ vertex: neighbor, path: newPath });
+          stack.push({vertex: neighbor, path: newPath});
         }
       }
     }
     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.
@@ -369,7 +366,6 @@ export abstract class AbstractGraph<
       } else {
         return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
-
     } else {
       // DFS
       let minPath: VO[] = [];
@@ -802,11 +798,6 @@ export abstract class AbstractGraph<
    * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
    * all pairs
    * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-   */
-
-  /**
-   * Floyd algorithm time: O(VO^3) space: O(VO^2), not support graph with negative weight cycle
-   * all pairs
    * /
 
    /**
@@ -815,12 +806,12 @@ export abstract class AbstractGraph<
    * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
    * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
    * graph.
-   * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`
+   * @returns The function `floydWarshall()` returns an object with two properties: `costs` and `predecessor`. The `costs`
    * property is a 2D array of numbers representing the shortest path costs between vertices in a graph. The
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
+  floydWarshall(): {costs: number[][]; predecessor: (VO | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -871,7 +862,7 @@ export abstract class AbstractGraph<
    * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
    * The `tarjan` function is used to perform various graph analysis tasks such as finding articulation points, bridges,
    * strongly connected components (SCCs), and cycles in a graph.
-   * @param {boolean} [needArticulationPoints] - A boolean value indicating whether or not to calculate and return the
+   * @param {boolean} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
    * articulation points in the graph. Articulation points are the vertices in a graph whose removal would increase the
    * number of connected components in the graph.
    * @param {boolean} [needBridges] - A boolean flag indicating whether the algorithm should find and return the bridges
@@ -884,13 +875,18 @@ export abstract class AbstractGraph<
    * are arrays of vertices that form cycles within the SCCs.
    * @returns The function `tarjan` returns an object with the following properties:
    */
-  tarjan(needArticulationPoints?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean) {
+  tarjan(
+    needCutVertexes: boolean = false,
+    needBridges: boolean = false,
+    needSCCs: boolean = true,
+    needCycles: boolean = false
+  ) {
     // !! in undirected graph we will not let child visit parent when dfs
     // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
     // !! bridge: low(child) > dfn(cur)
 
     const defaultConfig = false;
-    if (needArticulationPoints === undefined) needArticulationPoints = defaultConfig;
+    if (needCutVertexes === undefined) needCutVertexes = defaultConfig;
     if (needBridges === undefined) needBridges = defaultConfig;
     if (needSCCs === undefined) needSCCs = defaultConfig;
     if (needCycles === undefined) needCycles = defaultConfig;
@@ -905,7 +901,7 @@ export abstract class AbstractGraph<
 
     const [root] = vertices.values();
 
-    const articulationPoints: VO[] = [];
+    const cutVertexes: VO[] = [];
     const bridges: EO[] = [];
     let dfn = 0;
     const dfs = (cur: VO, parent: VO | null) => {
@@ -929,10 +925,10 @@ export abstract class AbstractGraph<
           }
           const curFromMap = dfnMap.get(cur);
           if (childLow !== undefined && curFromMap !== undefined) {
-            if (needArticulationPoints) {
+            if (needCutVertexes) {
               if ((cur === root && childCount >= 2) || (cur !== root && childLow >= curFromMap)) {
                 // todo not ensure the logic if (cur === root && childCount >= 2 || ((cur !== root) && (childLow >= curFromMap))) {
-                articulationPoints.push(cur);
+                cutVertexes.push(cur);
               }
             }
 
@@ -983,7 +979,59 @@ export abstract class AbstractGraph<
       });
     }
 
-    return {dfnMap, lowMap, bridges, articulationPoints, SCCs, cycles};
+    return {dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles};
+  }
+
+  /**
+   * The function returns a map that associates each vertex object with its corresponding depth-first
+   * number.
+   * @returns A Map object with keys of type VO and values of type number.
+   */
+  getDFNMap(): Map<VO, number> {
+    return this.tarjan(false, false, false, false).dfnMap;
+  }
+
+  /**
+   * The function returns a Map object that contains the low values of each vertex in a Tarjan
+   * algorithm.
+   * @returns The method `getLowMap()` is returning a `Map` object with keys of type `VO` and values of
+   * type `number`.
+   */
+  getLowMap(): Map<VO, number> {
+    return this.tarjan(false, false, false, false).lowMap;
+  }
+
+  /**
+   * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
+   * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
+   */
+  getCycles(): Map<number, VO[]> {
+    return this.tarjan(false, false, false, true).cycles;
+  }
+
+  /**
+   * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
+   * @returns an array of VO objects, specifically the cut vertexes.
+   */
+  getCutVertexes(): VO[] {
+    return this.tarjan(true, false, false, false).cutVertexes;
+  }
+
+  /**
+   * The function "getSCCs" returns a map of strongly connected components (SCCs) using the Tarjan
+   * algorithm.
+   * @returns a map where the keys are numbers and the values are arrays of VO objects.
+   */
+  getSCCs(): Map<number, VO[]> {
+    return this.tarjan(false, false, true, false).SCCs;
+  }
+
+  /**
+   * The function "getBridges" returns an array of bridges using the Tarjan algorithm.
+   * @returns the bridges found using the Tarjan algorithm.
+   */
+  getBridges() {
+    return this.tarjan(false, true, false, false).bridges;
   }
 
   protected abstract _addEdgeOnly(edge: EO): boolean;