min-heap-typed 1.50.1 → 1.50.3

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

@@ -24,7 +24,7 @@ export class UndirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export 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
@@ -38,7 +38,7 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    */
   constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this.vertexMap = [v1, v2];
+    this.endpoints = [v1, v2];
   }
 }
 
@@ -64,6 +64,10 @@ export class UndirectedGraph<
     return this._edgeMap;
   }
 
+  set edgeMap(v: Map<VO, EO[]>) {
+    this._edgeMap = v;
+  }
+
   /**
    * The function creates a new vertex with an optional value and returns it.
    * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
@@ -100,7 +104,7 @@ export class UndirectedGraph<
    * 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
@@ -115,7 +119,7 @@ export class UndirectedGraph<
       const vertex2: VO | undefined = 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));
       }
     }
 
@@ -135,7 +139,7 @@ export class UndirectedGraph<
    * @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 {
     const vertex1: VO | undefined = this._getVertex(v1);
@@ -148,11 +152,11 @@ export class UndirectedGraph<
     const v1Edges = this._edgeMap.get(vertex1);
     let removed: EO | undefined = undefined;
     if (v1Edges) {
-      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.vertexMap.includes(vertex2.key))[0] || undefined;
+      removed = arrayRemove<EO>(v1Edges, (e: EO) => e.endpoints.includes(vertex2.key))[0] || undefined;
     }
     const v2Edges = this._edgeMap.get(vertex2);
     if (v2Edges) {
-      arrayRemove<EO>(v2Edges, (e: EO) => e.vertexMap.includes(vertex1.key));
+      arrayRemove<EO>(v2Edges, (e: EO) => e.endpoints.includes(vertex1.key));
     }
     return removed;
   }
@@ -166,7 +170,7 @@ export class UndirectedGraph<
    * 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
@@ -185,8 +189,8 @@ export class UndirectedGraph<
         return;
       }
     } 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) {
@@ -228,7 +232,7 @@ export class UndirectedGraph<
         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);
         }
@@ -317,7 +321,7 @@ export class UndirectedGraph<
    * 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[]).
@@ -328,7 +332,7 @@ export class UndirectedGraph<
     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);
         }
@@ -346,18 +350,18 @@ export class UndirectedGraph<
    * 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 {
-    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];
     } else {
@@ -365,11 +369,159 @@ export class UndirectedGraph<
     }
   }
 
+  /**
+   * The isEmpty function checks if the graph is empty.
+   * @return True if the graph is empty and false otherwise
+   */
+  isEmpty(): boolean {
+    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<VertexKey, VO>();
+    this._edgeMap = new Map<VO, EO[]>();
+  }
+
+  /**
+   * 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
+   * assigning each of these properties to their respective counterparts in the
+   * cloned graph. The clone function returns a reference to this newly created,
+   * cloned UndirectedGraph object.
+   *
+   * @return A new instance of the undirectedgraph class
+   */
+  clone(): UndirectedGraph<V, E, VO, EO> {
+    const cloned = new UndirectedGraph<V, E, VO, EO>();
+    cloned.vertexMap = new Map<VertexKey, VO>(this.vertexMap);
+    cloned.edgeMap = new Map<VO, EO[]>(this.edgeMap);
+    return cloned;
+  }
+
   /**
    * 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[] } {
+    const dfnMap = new Map<VO, number>();
+    const lowMap = new Map<VO, number>();
+    const bridges: EO[] = [];
+    const cutVertices: VO[] = [];
+
+    let time = 0;
+
+    const dfs = (vertex: VO, parent: VO | undefined) => {
+      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)
@@ -379,7 +531,7 @@ export class UndirectedGraph<
    * @returns a boolean value.
    */
   protected _addEdge(edge: EO): boolean {
-    for (const end of edge.vertexMap) {
+    for (const end of edge.endpoints) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;
       if (endVertex) {