data-structure-typed 1.50.2 → 1.50.3

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

@@ -6,17 +6,118 @@
  * @license MIT License
  */
 export class SegmentTreeNode {
-    start = 0;
-    end = 0;
-    value = undefined;
-    sum = 0;
-    left = undefined;
-    right = undefined;
+    /**
+     * The constructor initializes the properties of a SegmentTreeNode object.
+     * @param {number} start - The `start` parameter represents the starting index of the segment covered
+     * by this node in a segment tree.
+     * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+     * node in a segment tree.
+     * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+     * the segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+     * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
+     */
     constructor(start, end, sum, value) {
-        this.start = start;
-        this.end = end;
-        this.sum = sum;
-        this.value = value || undefined;
+        this._start = start;
+        this._end = end;
+        this._sum = sum;
+        this._value = value || undefined;
+    }
+    _start = 0;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
+    get start() {
+        return this._start;
+    }
+    /**
+     * The above function sets the value of the "start" property.
+     * @param {number} value - The value parameter is of type number.
+     */
+    set start(value) {
+        this._start = value;
+    }
+    _end = 0;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
+    get end() {
+        return this._end;
+    }
+    /**
+     * The above function sets the value of the "end" property.
+     * @param {number} value - The value parameter is a number that represents the new value for the end
+     * property.
+     */
+    set end(value) {
+        this._end = value;
+    }
+    _value = undefined;
+    /**
+     * The function returns the value of a segment tree node.
+     * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * The function sets the value of a segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+     * `SegmentTreeNodeVal` or `undefined`.
+     */
+    set value(value) {
+        this._value = value;
+    }
+    _sum = 0;
+    /**
+     * The function returns the value of the sum property.
+     * @returns The method is returning the value of the variable `_sum`.
+     */
+    get sum() {
+        return this._sum;
+    }
+    /**
+     * The above function sets the value of the sum property.
+     * @param {number} value - The parameter "value" is of type "number".
+     */
+    set sum(value) {
+        this._sum = value;
+    }
+    _left = undefined;
+    /**
+     * The function returns the left child of a segment tree node.
+     * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+     * `SegmentTreeNode` or `undefined`.
+     */
+    get left() {
+        return this._left;
+    }
+    /**
+     * The function sets the value of the left property of a SegmentTreeNode object.
+     * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+     * undefined.
+     */
+    set left(value) {
+        this._left = value;
+    }
+    _right = undefined;
+    /**
+     * The function returns the right child of a segment tree node.
+     * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+     */
+    get right() {
+        return this._right;
+    }
+    /**
+     * The function sets the right child of a segment tree node.
+     * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+     * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+     * value.
+     */
+    set right(value) {
+        this._right = value;
     }
 }
 export class SegmentTree {
@@ -44,18 +145,34 @@ export class SegmentTree {
         }
     }
     _values = [];
+    /**
+     * The function returns an array of numbers.
+     * @returns An array of numbers is being returned.
+     */
     get values() {
         return this._values;
     }
     _start = 0;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
     get start() {
         return this._start;
     }
     _end;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
     get end() {
         return this._end;
     }
     _root;
+    /**
+     * The function returns the root node of a segment tree.
+     * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+     */
     get root() {
         return this._root;
     }

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

@@ -10,7 +10,6 @@ import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
-    count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -22,13 +21,30 @@ export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultima
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: K, value?: V, count?: number);
+    protected _count: number;
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count(): number;
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value: number);
 }
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, NODE, TREE> = TreeMultimap<K, V, NODE, TreeMultimapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultimapOptions<K>);
-    private _count;
+    protected _count: number;
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -40,6 +56,15 @@ export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNod
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
     createNode(key: K, value?: V, count?: number): NODE;
+    /**
+     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
@@ -154,5 +179,13 @@ export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNod
      * if either `srcNode` or `destNode` is undefined.
      */
     protected _swapProperties(srcNode: BSTNKeyOrNode<K, NODE>, destNode: BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

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

@@ -1,7 +1,6 @@
 import { FamilyPosition, IterationType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultimapNode extends AVLTreeNode {
-    count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -16,6 +15,22 @@ export class TreeMultimapNode extends AVLTreeNode {
         super(key, value);
         this.count = count;
     }
+    _count = 1;
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+        return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+        this._count = value;
+    }
 }
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -28,6 +43,11 @@ export class TreeMultimap extends AVLTree {
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
@@ -45,6 +65,15 @@ export class TreeMultimap extends AVLTree {
     createNode(key, value, count) {
         return new TreeMultimapNode(key, value, count);
     }
+    /**
+     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options) {
         return new TreeMultimap([], {
             iterationType: this.iterationType,
@@ -319,6 +348,14 @@ export class TreeMultimap extends AVLTree {
         }
         return undefined;
     }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     _replaceNode(oldNode, newNode) {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);

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

@@ -362,84 +362,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
         costs: number[][];
         predecessor: (VO | undefined)[][];
     };
-    /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * /
-  
-     /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     *
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * 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} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-     * articulation points in the graph. Articulation points are the vertexMap 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
-     * (edgeMap whose removal would increase the number of connected components in the graph).
-     * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-     * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-     * SCCs will not be calculated or returned.
-     * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-     * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-     * are arrays of vertexMap that form cycles within the SCCs.
-     * @returns The function `tarjan` returns an object with the following properties:
-     */
-    tarjan(needCutVertexes?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean): {
-        dfnMap: Map<VO, number>;
-        lowMap: Map<VO, number>;
-        bridges: EO[];
-        cutVertexes: VO[];
-        SCCs: Map<number, VO[]>;
-        cycles: Map<number, VO[]>;
-    };
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     */
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     *
-     * 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 "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[];
     /**
      * O(V+E+C)
      * O(V+C)

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

@@ -816,194 +816,6 @@ export class AbstractGraph extends IterableEntryBase {
         }
         return { costs, predecessor };
     }
-    /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
-     * /
-  
-     /**
-     * Time Complexity: O(V + E) - Linear time (Tarjan's algorithm).
-     * Space Complexity: O(V) - Linear space (Tarjan's algorithm).
-     *
-     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
-     * Tarjan can find cycles in directed or undirected graph
-     * Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time,
-     * Tarjan solve the bi-connected components of undirected graphs;
-     * 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} [needCutVertexes] - A boolean value indicating whether or not to calculate and return the
-     * articulation points in the graph. Articulation points are the vertexMap 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
-     * (edgeMap whose removal would increase the number of connected components in the graph).
-     * @param {boolean} [needSCCs] - A boolean value indicating whether the Strongly Connected Components (SCCs) of the
-     * graph are needed. If set to true, the function will calculate and return the SCCs of the graph. If set to false, the
-     * SCCs will not be calculated or returned.
-     * @param {boolean} [needCycles] - A boolean flag indicating whether the algorithm should find cycles in the graph. If
-     * set to true, the algorithm will return a map of cycles, where the keys are the low values of the SCCs and the values
-     * are arrays of vertexMap that form cycles within the SCCs.
-     * @returns The function `tarjan` returns an object with the following properties:
-     */
-    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 (needCutVertexes === undefined)
-            needCutVertexes = defaultConfig;
-        if (needBridges === undefined)
-            needBridges = defaultConfig;
-        if (needSCCs === undefined)
-            needSCCs = defaultConfig;
-        if (needCycles === undefined)
-            needCycles = defaultConfig;
-        const dfnMap = new Map();
-        const lowMap = new Map();
-        const vertexMap = this._vertexMap;
-        vertexMap.forEach(v => {
-            dfnMap.set(v, -1);
-            lowMap.set(v, Infinity);
-        });
-        const [root] = vertexMap.values();
-        const cutVertexes = [];
-        const bridges = [];
-        let dfn = 0;
-        const dfs = (cur, parent) => {
-            dfn++;
-            dfnMap.set(cur, dfn);
-            lowMap.set(cur, dfn);
-            const neighbors = this.getNeighbors(cur);
-            let childCount = 0; // child in dfs tree not child in graph
-            for (const neighbor of neighbors) {
-                if (neighbor !== parent) {
-                    if (dfnMap.get(neighbor) === -1) {
-                        childCount++;
-                        dfs(neighbor, cur);
-                    }
-                    const childLow = lowMap.get(neighbor);
-                    const curLow = lowMap.get(cur);
-                    // TODO after no-non-undefined-assertion not ensure the logic
-                    if (curLow !== undefined && childLow !== undefined) {
-                        lowMap.set(cur, Math.min(curLow, childLow));
-                    }
-                    const curFromMap = dfnMap.get(cur);
-                    if (childLow !== undefined && curFromMap !== undefined) {
-                        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))) {
-                                cutVertexes.push(cur);
-                            }
-                        }
-                        if (needBridges) {
-                            if (childLow > curFromMap) {
-                                const edgeCurToNeighbor = this.getEdge(cur, neighbor);
-                                if (edgeCurToNeighbor) {
-                                    bridges.push(edgeCurToNeighbor);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        };
-        dfs(root, undefined);
-        let SCCs = new Map();
-        const getSCCs = () => {
-            const SCCs = new Map();
-            lowMap.forEach((low, vertex) => {
-                if (!SCCs.has(low)) {
-                    SCCs.set(low, [vertex]);
-                }
-                else {
-                    SCCs.get(low)?.push(vertex);
-                }
-            });
-            return SCCs;
-        };
-        if (needSCCs) {
-            SCCs = getSCCs();
-        }
-        const cycles = new Map();
-        if (needCycles) {
-            const visitedMap = new Map();
-            const stack = [];
-            const findCyclesDFS = (cur, parent) => {
-                visitedMap.set(cur, true);
-                stack.push(cur);
-                const neighbors = this.getNeighbors(cur);
-                for (const neighbor of neighbors) {
-                    if (!visitedMap.get(neighbor)) {
-                        findCyclesDFS(neighbor, cur);
-                    }
-                    else if (stack.includes(neighbor) && neighbor !== parent) {
-                        const cycleStartIndex = stack.indexOf(neighbor);
-                        const cycle = stack.slice(cycleStartIndex);
-                        const cycleLow = Math.min(...cycle.map(v => dfnMap.get(v) || Infinity));
-                        cycles.set(cycleLow, cycle);
-                    }
-                }
-                stack.pop();
-            };
-            vertexMap.forEach(v => {
-                if (!visitedMap.get(v)) {
-                    findCyclesDFS(v, undefined);
-                }
-            });
-        }
-        return { dfnMap, lowMap, bridges, cutVertexes, SCCs, cycles };
-    }
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     */
-    /**
-     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
-     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
-     *
-     * 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 "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;
-    }
     /**
      * O(V+E+C)
      * O(V+C)

package/dist/mjs/data-structures/graph/directed-graph.d.ts

@@ -335,12 +335,71 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * @return A boolean value
      */
     isEmpty(): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex map, in-edge map, and out-edge map.
+     */
+    clear(): void;
     /**
      * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
      *
      * @return A new instance of the directedgraph class
      */
     clone(): DirectedGraph<V, E, VO, EO>;
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     */
+    /**
+     *  Time Complexity: O(V + E)
+     *  Space Complexity: O(V)
+     *  Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
+     *  Tarjan can find the SSC(strongly connected components), articulation points, and bridges of directed graphs.
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find strongly connected components in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with three properties: `dfnMap`, `lowMap`, and
+     * `SCCs`.
+     */
+    tarjan(): {
+        dfnMap: Map<VO, number>;
+        lowMap: Map<VO, number>;
+        SCCs: Map<number, VO[]>;
+    };
+    /**
+     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
+     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
+     */
+    /**
+     * Time Complexity: O(V + E) - Depends on the implementation (Tarjan's algorithm).
+     * Space Complexity: O(V) - Depends on the implementation (Tarjan's algorithm).
+     *
+     * 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 "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[]>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)