data-structure-typed 1.50.2 → 1.50.3

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

@@ -538,6 +538,21 @@ export class DirectedGraph extends AbstractGraph {
     isEmpty() {
         return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
     }
+    /**
+     * 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() {
+        this._vertexMap = new Map();
+        this._inEdgeMap = new Map();
+        this._outEdgeMap = new Map();
+    }
     /**
      * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
      *
@@ -550,6 +565,96 @@ export class DirectedGraph extends AbstractGraph {
         cloned.outEdgeMap = new Map(this.outEdgeMap);
         return cloned;
     }
+    /**
+     *  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() {
+        const dfnMap = new Map();
+        const lowMap = new Map();
+        const SCCs = new Map();
+        let time = 0;
+        const stack = [];
+        const inStack = new Set();
+        const dfs = (vertex) => {
+            dfnMap.set(vertex, time);
+            lowMap.set(vertex, time);
+            time++;
+            stack.push(vertex);
+            inStack.add(vertex);
+            const neighbors = this.getNeighbors(vertex);
+            for (const neighbor of neighbors) {
+                if (!dfnMap.has(neighbor)) {
+                    dfs(neighbor);
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+                }
+                else if (inStack.has(neighbor)) {
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+                }
+            }
+            if (dfnMap.get(vertex) === lowMap.get(vertex)) {
+                const SCC = [];
+                let poppedVertex;
+                do {
+                    poppedVertex = stack.pop();
+                    inStack.delete(poppedVertex);
+                    SCC.push(poppedVertex);
+                } while (poppedVertex !== vertex);
+                SCCs.set(SCCs.size, SCC);
+            }
+        };
+        for (const vertex of this.vertexMap.values()) {
+            if (!dfnMap.has(vertex)) {
+                dfs(vertex);
+            }
+        }
+        return { dfnMap, lowMap, SCCs };
+    }
+    /**
+     * 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().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().lowMap;
+    }
+    /**
+     * 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().SCCs;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -19,7 +19,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     constructor(key: VertexKey, value?: V);
 }
 export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
-    vertexMap: [VertexKey, VertexKey];
+    endpoints: [VertexKey, VertexKey];
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -69,7 +69,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two endpoints, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -89,7 +89,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the endpoints (VO) does not exist.
      */
     deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | undefined;
     /**
@@ -100,7 +100,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * The function `deleteEdge` deletes an edge between two endpoints in a graph.
      * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
      * either an edge object or a vertex key.
      * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -173,7 +173,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring endpoints for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
      * @returns an array of vertexMap (VO[]).
@@ -187,10 +187,10 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the endpoints at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two endpoints `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge: EO): [VO, VO] | undefined;
@@ -199,6 +199,17 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @return True if the graph is empty and false otherwise
      */
     isEmpty(): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex and edge maps to empty maps.
+     */
+    clear(): void;
     /**
      * The clone function creates a new UndirectedGraph object and copies the
      * vertexMap and edgeMap from this graph to the new one. This is done by
@@ -213,6 +224,48 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     *  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.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with the following properties:
+     */
+    tarjan(): {
+        dfnMap: Map<VO, number>;
+        lowMap: Map<VO, number>;
+        bridges: EO[];
+        cutVertices: VO[];
+    };
+    /**
+     *  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.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     */
+    /**
+     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
+     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
+     */
+    getBridges(): EO[];
+    /**
+     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
+     * @returns the cut vertices found using the Tarjan's algorithm.
+     */
+    getCutVertices(): VO[];
+    /**
+     * The function returns the dfnMap property of the result of the tarjan() function.
+     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
+     */
+    getDFNMap(): Map<VO, number>;
+    /**
+     * The function returns the lowMap property of the result of the tarjan() function.
+     * @returns the lowMap property of the result of calling the tarjan() function.
+     */
+    getLowMap(): Map<VO, number>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -13,7 +13,7 @@ export class UndirectedVertex extends AbstractVertex {
     }
 }
 export class UndirectedEdge extends AbstractEdge {
-    vertexMap;
+    endpoints;
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -26,7 +26,7 @@ export class UndirectedEdge extends AbstractEdge {
      */
     constructor(v1, v2, weight, value) {
         super(weight, value);
-        this.vertexMap = [v1, v2];
+        this.endpoints = [v1, v2];
     }
 }
 export class UndirectedGraph extends AbstractGraph {
@@ -77,7 +77,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(|E|), where |E| is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `getEdge` returns the first edge that connects two vertexMap, or undefined if no such edge exists.
+     * The function `getEdge` returns the first edge that connects two endpoints, or undefined if no such edge exists.
      * @param {VO | VertexKey | undefined} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `undefined`, or `VertexKey` (a string or number representing the ID of a vertex).
      * @param {VO | VertexKey | undefined} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
@@ -90,7 +90,7 @@ export class UndirectedGraph extends AbstractGraph {
             const vertex1 = this._getVertex(v1);
             const vertex2 = this._getVertex(v2);
             if (vertex1 && vertex2) {
-                edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.vertexMap.includes(vertex2.key));
+                edgeMap = this._edgeMap.get(vertex1)?.filter(e => e.endpoints.includes(vertex2.key));
             }
         }
         return edgeMap ? edgeMap[0] || undefined : undefined;
@@ -107,7 +107,7 @@ export class UndirectedGraph extends AbstractGraph {
      * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
      * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (EO) if it exists, or undefined if either of the vertexMap (VO) does not exist.
+     * @returns the removed edge (EO) if it exists, or undefined if either of the endpoints (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
@@ -118,11 +118,11 @@ export class UndirectedGraph extends AbstractGraph {
         const v1Edges = this._edgeMap.get(vertex1);
         let removed = undefined;
         if (v1Edges) {
-            removed = arrayRemove(v1Edges, (e) => e.vertexMap.includes(vertex2.key))[0] || undefined;
+            removed = arrayRemove(v1Edges, (e) => e.endpoints.includes(vertex2.key))[0] || undefined;
         }
         const v2Edges = this._edgeMap.get(vertex2);
         if (v2Edges) {
-            arrayRemove(v2Edges, (e) => e.vertexMap.includes(vertex1.key));
+            arrayRemove(v2Edges, (e) => e.endpoints.includes(vertex1.key));
         }
         return removed;
     }
@@ -134,7 +134,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
      * Space Complexity: O(1)
      *
-     * The function `deleteEdge` deletes an edge between two vertexMap in a graph.
+     * The function `deleteEdge` deletes an edge between two endpoints in a graph.
      * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
      * either an edge object or a vertex key.
      * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
@@ -155,8 +155,8 @@ export class UndirectedGraph extends AbstractGraph {
             }
         }
         else {
-            oneSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[0]);
-            otherSide = this._getVertex(edgeOrOneSideVertexKey.vertexMap[1]);
+            oneSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[0]);
+            otherSide = this._getVertex(edgeOrOneSideVertexKey.endpoints[1]);
         }
         if (oneSide && otherSide) {
             return this.deleteEdgeBetween(oneSide, otherSide);
@@ -195,7 +195,7 @@ export class UndirectedGraph extends AbstractGraph {
                 const neighborEdges = this._edgeMap.get(neighbor);
                 if (neighborEdges) {
                     const restEdges = neighborEdges.filter(edge => {
-                        return !edge.vertexMap.includes(vertexKey);
+                        return !edge.endpoints.includes(vertexKey);
                     });
                     this._edgeMap.set(neighbor, restEdges);
                 }
@@ -277,7 +277,7 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(|V| + |E|), where |V| is the number of vertexMap and |E| is the number of edgeMap.
      * Space Complexity: O(|E|)
      *
-     * The function "getNeighbors" returns an array of neighboring vertexMap for a given vertex or vertex ID.
+     * The function "getNeighbors" returns an array of neighboring endpoints for a given vertex or vertex ID.
      * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
      * @returns an array of vertexMap (VO[]).
@@ -288,7 +288,7 @@ export class UndirectedGraph extends AbstractGraph {
         if (vertex) {
             const neighborEdges = this.edgesOf(vertex);
             for (const edge of neighborEdges) {
-                const neighbor = this._getVertex(edge.vertexMap.filter(e => e !== vertex.key)[0]);
+                const neighbor = this._getVertex(edge.endpoints.filter(e => e !== vertex.key)[0]);
                 if (neighbor) {
                     neighbors.push(neighbor);
                 }
@@ -304,18 +304,18 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function "getEndsOfEdge" returns the vertexMap at the ends of an edge if the edge exists in the graph, otherwise
+     * The function "getEndsOfEdge" returns the endpoints at the ends of an edge if the edge exists in the graph, otherwise
      * it returns undefined.
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertexMap `[VO, VO]` if the edge exists in the
+     * @returns The function `getEndsOfEdge` returns an array containing two endpoints `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge) {
-        if (!this.hasEdge(edge.vertexMap[0], edge.vertexMap[1])) {
+        if (!this.hasEdge(edge.endpoints[0], edge.endpoints[1])) {
             return undefined;
         }
-        const v1 = this._getVertex(edge.vertexMap[0]);
-        const v2 = this._getVertex(edge.vertexMap[1]);
+        const v1 = this._getVertex(edge.endpoints[0]);
+        const v2 = this._getVertex(edge.endpoints[1]);
         if (v1 && v2) {
             return [v1, v2];
         }
@@ -330,6 +330,20 @@ export class UndirectedGraph extends AbstractGraph {
     isEmpty() {
         return this.vertexMap.size === 0 && this.edgeMap.size === 0;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The clear function resets the vertex and edge maps to empty maps.
+     */
+    clear() {
+        this._vertexMap = new Map();
+        this._edgeMap = new Map();
+    }
     /**
      * The clone function creates a new UndirectedGraph object and copies the
      * vertexMap and edgeMap from this graph to the new one. This is done by
@@ -349,6 +363,100 @@ export class UndirectedGraph extends AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     *  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.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     *
+     * The function `tarjan` implements the Tarjan's algorithm to find bridges and cut vertices in a
+     * graph.
+     * @returns The function `tarjan()` returns an object with the following properties:
+     */
+    tarjan() {
+        const dfnMap = new Map();
+        const lowMap = new Map();
+        const bridges = [];
+        const cutVertices = [];
+        let time = 0;
+        const dfs = (vertex, parent) => {
+            dfnMap.set(vertex, time);
+            lowMap.set(vertex, time);
+            time++;
+            const neighbors = this.getNeighbors(vertex);
+            let childCount = 0;
+            for (const neighbor of neighbors) {
+                if (!dfnMap.has(neighbor)) {
+                    childCount++;
+                    dfs(neighbor, vertex);
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+                    if (lowMap.get(neighbor) > dfnMap.get(vertex)) {
+                        // Found a bridge
+                        const edge = this.getEdge(vertex, neighbor);
+                        if (edge) {
+                            bridges.push(edge);
+                        }
+                    }
+                    if (parent !== undefined && lowMap.get(neighbor) >= dfnMap.get(vertex)) {
+                        // Found an articulation point
+                        cutVertices.push(vertex);
+                    }
+                }
+                else if (neighbor !== parent) {
+                    lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+                }
+            }
+            if (parent === undefined && childCount > 1) {
+                // Special case for root in DFS tree
+                cutVertices.push(vertex);
+            }
+        };
+        for (const vertex of this.vertexMap.values()) {
+            if (!dfnMap.has(vertex)) {
+                dfs(vertex, undefined);
+            }
+        }
+        return {
+            dfnMap,
+            lowMap,
+            bridges,
+            cutVertices
+        };
+    }
+    /**
+     *  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.
+     *  1. Tarjan can find the articulation points and bridges(critical edgeMap) of undirected graphs in linear time
+     */
+    /**
+     * The function "getBridges" returns an array of bridges in a graph using the Tarjan's algorithm.
+     * @returns The function `getBridges()` is returning the bridges found using the Tarjan's algorithm.
+     */
+    getBridges() {
+        return this.tarjan().bridges;
+    }
+    /**
+     * The function "getCutVertices" returns an array of cut vertices using the Tarjan's algorithm.
+     * @returns the cut vertices found using the Tarjan's algorithm.
+     */
+    getCutVertices() {
+        return this.tarjan().cutVertices;
+    }
+    /**
+     * The function returns the dfnMap property of the result of the tarjan() function.
+     * @returns the `dfnMap` property of the result of calling the `tarjan()` function.
+     */
+    getDFNMap() {
+        return this.tarjan().dfnMap;
+    }
+    /**
+     * The function returns the lowMap property of the result of the tarjan() function.
+     * @returns the lowMap property of the result of calling the tarjan() function.
+     */
+    getLowMap() {
+        return this.tarjan().lowMap;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -358,7 +466,7 @@ export class UndirectedGraph extends AbstractGraph {
      * @returns a boolean value.
      */
     _addEdge(edge) {
-        for (const end of edge.vertexMap) {
+        for (const end of edge.endpoints) {
             const endVertex = this._getVertex(end);
             if (endVertex === undefined)
                 return false;