data-structure-typed 1.50.1 → 1.50.3

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

@@ -40,6 +40,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     constructor();
     protected _vertexMap: Map<VertexKey, VO>;
     get vertexMap(): Map<VertexKey, VO>;
+    set vertexMap(v: Map<VertexKey, VO>);
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -361,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

@@ -47,6 +47,9 @@ export class AbstractGraph extends IterableEntryBase {
     get vertexMap() {
         return this._vertexMap;
     }
+    set vertexMap(v) {
+        this._vertexMap = v;
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -813,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

@@ -41,8 +41,10 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
     constructor();
     protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
+    set outEdgeMap(v: Map<VO, EO[]>);
     protected _inEdgeMap: Map<VO, EO[]>;
     get inEdgeMap(): Map<VO, EO[]>;
+    set inEdgeMap(v: Map<VO, EO[]>);
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -327,6 +329,77 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge: EO): [VO, VO] | undefined;
+    /**
+     * The isEmpty function checks if the graph is empty.
+     *
+     * @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)

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

@@ -43,10 +43,16 @@ export class DirectedGraph extends AbstractGraph {
     get outEdgeMap() {
         return this._outEdgeMap;
     }
+    set outEdgeMap(v) {
+        this._outEdgeMap = v;
+    }
     _inEdgeMap = new Map();
     get inEdgeMap() {
         return this._inEdgeMap;
     }
+    set inEdgeMap(v) {
+        this._inEdgeMap = v;
+    }
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -524,6 +530,131 @@ export class DirectedGraph extends AbstractGraph {
             return undefined;
         }
     }
+    /**
+     * The isEmpty function checks if the graph is empty.
+     *
+     * @return A boolean value
+     */
+    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.
+     *
+     * @return A new instance of the directedgraph class
+     */
+    clone() {
+        const cloned = new DirectedGraph();
+        cloned.vertexMap = new Map(this.vertexMap);
+        cloned.inEdgeMap = new Map(this.inEdgeMap);
+        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/map-graph.d.ts

@@ -70,4 +70,12 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
     createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
+    /**
+     * The override function is used to override the default behavior of a function.
+     * In this case, we are overriding the clone() function from Graph&lt;V, E&gt;.
+     * The clone() function returns a new graph that is an exact copy of the original graph.
+     *
+     * @return A mapgraph&lt;v, e, vo, eo&gt;
+     */
+    clone(): MapGraph<V, E, VO, EO>;
 }

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

@@ -87,4 +87,18 @@ export class MapGraph extends DirectedGraph {
     createEdge(src, dest, weight, value) {
         return new MapEdge(src, dest, weight, value);
     }
+    /**
+     * The override function is used to override the default behavior of a function.
+     * In this case, we are overriding the clone() function from Graph<V, E>.
+     * The clone() function returns a new graph that is an exact copy of the original graph.
+     *
+     * @return A mapgraph<v, e, vo, eo>
+     */
+    clone() {
+        const cloned = new MapGraph(this.originCoord, this.bottomRight);
+        cloned.vertexMap = new Map(this.vertexMap);
+        cloned.inEdgeMap = new Map(this.inEdgeMap);
+        cloned.outEdgeMap = new Map(this.outEdgeMap);
+        return cloned;
+    }
 }