data-structure-typed 1.42.1 → 1.42.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.42.1",
+  "version": "1.42.3",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/cjs/src/index.js",
   "module": "dist/mjs/src/index.js",
@@ -41,7 +41,7 @@
     "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
     "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
-    "publish:all": "npm run ci && npm run benchmark && npm publish && npm run publish:docs && npm run publish:subs"
+    "publish:all": "npm run ci && npm publish && npm run publish:docs && npm run publish:subs"
   },
   "repository": {
     "type": "git",

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;

package/test/performance/reportor.ts

@@ -107,6 +107,7 @@ const composeReport = () => {
   fs.writeFileSync(htmlFilePath, html);
   console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
 };
+
 function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
   const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
   const filePath = path.join(parentDirectory, 'README.md'); // Path to README.md file

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -174,10 +174,14 @@ describe('BinaryTree', () => {
 
   it('should subTreeTraverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6,3, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6,3, 7]);
-    expect(tree.subTreeTraverse(node => node === null? null : node.key, tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([6, 3, 7, null]);
-    expect(tree.subTreeTraverse(node => node === null? null : node.key, tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 3, 7, null]);
+    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
+    expect(
+      tree.subTreeTraverse(node => (node === null ? null : node.key), tree.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node === null ? null : node.key), tree.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 3, 7, null]);
   });
 
   it('should clear the tree', () => {
@@ -268,17 +272,33 @@ describe('BinaryTree traversals', () => {
 
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
-  expect(tree.bfs(node => node , tree.root, IterationType.ITERATIVE, true).map(node => node === null ? null : node.key)).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node , tree.root, IterationType.RECURSIVE, true).map(node => node === null ? null : node.key)).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node , tree.root, IterationType.ITERATIVE).map(node => node === null ? null : node.key)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node , tree.root, IterationType.RECURSIVE).map(node => node === null ? null : node.key)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
   expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([
     35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
   ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => node === null ? null : node.key)).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true).map(node => node === null ? null : node.key)).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
+  expect(
+    tree
+      .dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true)
+      .map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
+  expect(
+    tree
+      .dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true)
+      .map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
@@ -300,21 +320,20 @@ describe('BinaryTree traversals', () => {
     [15, 29, 50],
     [16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => node === null ? null :node.key, tree.root, IterationType.ITERATIVE, true)).toEqual([
+  expect(tree.listLevels(node => (node === null ? null : node.key), tree.root, IterationType.ITERATIVE, true)).toEqual([
     [35],
     [20, 40],
-    [15, 29, null,50],
+    [15, 29, null, 50],
     [null, 16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => node === null ? null :node.key, tree.root, IterationType.RECURSIVE, true)).toEqual([
+  expect(tree.listLevels(node => (node === null ? null : node.key), tree.root, IterationType.RECURSIVE, true)).toEqual([
     [35],
     [20, 40],
-    [15, 29, null,50],
+    [15, 29, null, 50],
     [null, 16, 28, 30, 45, 55]
   ]);
 });
 
-
 describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -837,4 +837,17 @@ describe('BST Performance test', function () {
     bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
     expect(bst.lastKey()).toBe(9);
   });
+
+  it('should subTreeTraverse, null should be ignored', () => {
+    const bst = new BST();
+    bst.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
+    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
+    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+    expect(
+      bst.subTreeTraverse(node => (node === null ? null : node.key), bst.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 5, 7]);
+    expect(
+      bst.subTreeTraverse(node => (node === null ? null : node.key), bst.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 5, 7]);
+  });
 });

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -340,7 +340,7 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     expect(min).toBe(Infinity);
     expect(minPath).toBeInstanceOf(Array);
 
-    const floydResult = myGraph.floyd();
+    const floydResult = myGraph.floydWarshall();
     expect(floydResult).toBeTruthy();
     if (floydResult) {
       const {costs, predecessor} = floydResult;
@@ -562,3 +562,36 @@ describe('Inherit from DirectedGraph and perform operations test2.', () => {
     }
   });
 });
+
+describe('cycles, strongly connected components, bridges, articular points in DirectedGraph', () => {
+  const graph = new DirectedGraph();
+  graph.addVertex('A');
+  graph.addVertex('B');
+  graph.addVertex('C');
+  graph.addVertex('D');
+  graph.addVertex('E');
+  graph.addVertex('F');
+  graph.addVertex('G');
+  graph.addVertex('H');
+  graph.addEdge('A', 'B');
+  graph.addEdge('B', 'D');
+  graph.addEdge('D', 'C');
+  graph.addEdge('C', 'A');
+  graph.addEdge('C', 'B');
+  graph.addEdge('D', 'E');
+  graph.addEdge('E', 'G');
+  graph.addEdge('E', 'H');
+  graph.addEdge('H', 'F');
+  const cycles = graph.getCycles();
+  const scCs = graph.getSCCs();
+  const bridges = graph.getBridges();
+  const cutVertexes = graph.getCutVertexes();
+  const dfnMap = graph.getDFNMap();
+  const lowMap = graph.getLowMap();
+  expect(cycles.size).toBe(1);
+  expect(scCs.size).toBe(5);
+  expect(bridges.length).toBe(4);
+  expect(cutVertexes.length).toBe(4);
+  expect(dfnMap.size).toBe(8);
+  expect(lowMap.size).toBe(8);
+});