data-structure-typed 1.18.6 → 1.18.8

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

@@ -1,5 +1,5 @@
 import type { DijkstraResult, VertexId } from '../types';
-import { IGraph } from '../interfaces';
+import { IAbstractGraph } from '../interfaces';
 export declare abstract class AbstractVertex<T = number> {
     protected constructor(id: VertexId, val?: T);
     private _id;
@@ -21,7 +21,7 @@ export declare abstract class AbstractEdge<T = number> {
     get hashCode(): string;
     protected _setHashCode(v: string): void;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IGraph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IAbstractGraph<V, E> {
     private _vertices;
     get vertices(): Map<VertexId, V>;
     /**
@@ -30,7 +30,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @param id
      * @param val
      */
-    abstract _createVertex(id: VertexId, val?: V): V;
+    abstract createVertex(id: VertexId, val?: V): 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.
@@ -39,12 +39,9 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @param weight
      * @param val
      */
-    abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
-    abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    abstract createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
     abstract removeEdge(edge: E): E | null;
-    _getVertex(vertexOrId: VertexId | V): V | null;
     getVertex(vertexId: VertexId): V | null;
-    _getVertexId(vertexOrId: V | VertexId): VertexId;
     /**
      * The function checks if a vertex exists in a graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
@@ -53,8 +50,8 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      */
     hasVertex(vertexOrId: V | VertexId): boolean;
     abstract getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    createAddVertex(id: VertexId, val?: V['val']): boolean;
-    addVertex(newVertex: V): boolean;
+    addVertex(vertex: V): boolean;
+    addVertex(id: VertexId, val?: V['val']): boolean;
     /**
      * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
@@ -83,8 +80,8 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * vertices `v1` and `v2`, and `false` otherwise.
      */
     hasEdge(v1: VertexId | V, v2: VertexId | V): boolean;
-    createAddEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E['val']): boolean;
-    abstract addEdge(edge: E): boolean;
+    addEdge(edge: E): boolean;
+    addEdge(src: V | VertexId, dest: V | VertexId, weight?: number, val?: E['val']): boolean;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
      * @param {VertexId | V} srcOrId - The `srcOrId` parameter can be either a `VertexId` or a `V` object. It represents
@@ -179,11 +176,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<V>`.
      */
     dijkstra(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
-    /**
-     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
-     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-     */
     /**
      * Dijkstra algorithm time: O(logVE) space: O(V + E)
      * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
@@ -213,12 +205,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         min: number;
         minPath: V[];
     };
-    /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -234,11 +220,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         costs: number[][];
         predecessor: (V | null)[][];
     };
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * 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
@@ -268,6 +249,26 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         SCCs: Map<number, V[]>;
         cycles: Map<number, V[]>;
     };
+    /**
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
+     */
+    protected _addVertexOnly(newVertex: V): boolean;
+    protected abstract _addEdgeOnly(edge: E): boolean;
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     */
+    protected _getVertex(vertexOrId: VertexId | V): V | null;
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
+     */
+    protected _getVertexId(vertexOrId: V | VertexId): VertexId;
     /**--- start find cycles --- */
     protected _setVertices(value: Map<VertexId, V>): void;
 }

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

@@ -115,7 +115,7 @@ var AbstractEdge = /** @class */ (function () {
     //  * @param weight
     //  * @param val
     //  */
-    // abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
+    // abstract createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
     AbstractEdge.prototype._setHashCode = function (v) {
         this._hashCode = v;
     };
@@ -137,16 +137,9 @@ var AbstractGraph = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    AbstractGraph.prototype._getVertex = function (vertexOrId) {
-        var vertexId = this._getVertexId(vertexOrId);
-        return this._vertices.get(vertexId) || null;
-    };
     AbstractGraph.prototype.getVertex = function (vertexId) {
         return this._vertices.get(vertexId) || null;
     };
-    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
-        return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
-    };
     /**
      * The function checks if a vertex exists in a graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
@@ -156,17 +149,14 @@ var AbstractGraph = /** @class */ (function () {
     AbstractGraph.prototype.hasVertex = function (vertexOrId) {
         return this._vertices.has(this._getVertexId(vertexOrId));
     };
-    AbstractGraph.prototype.createAddVertex = function (id, val) {
-        var newVertex = this._createVertex(id, val);
-        return this.addVertex(newVertex);
-    };
-    AbstractGraph.prototype.addVertex = function (newVertex) {
-        if (this.hasVertex(newVertex)) {
-            return false;
-            // throw (new Error('Duplicated vertex id is not allowed'));
+    AbstractGraph.prototype.addVertex = function (idOrVertex, val) {
+        if (idOrVertex instanceof AbstractVertex) {
+            return this._addVertexOnly(idOrVertex);
+        }
+        else {
+            var newVertex = this.createVertex(idOrVertex, val);
+            return this._addVertexOnly(newVertex);
         }
-        this._vertices.set(newVertex.id, newVertex);
-        return true;
     };
     /**
      * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
@@ -216,13 +206,25 @@ var AbstractGraph = /** @class */ (function () {
         var edge = this.getEdge(v1, v2);
         return !!edge;
     };
-    AbstractGraph.prototype.createAddEdge = function (src, dest, weight, val) {
-        if (src instanceof AbstractVertex)
-            src = src.id;
-        if (dest instanceof AbstractVertex)
-            dest = dest.id;
-        var newEdge = this._createEdge(src, dest, weight, val);
-        return this.addEdge(newEdge);
+    AbstractGraph.prototype.addEdge = function (srcOrEdge, dest, weight, val) {
+        if (srcOrEdge instanceof AbstractEdge) {
+            return this._addEdgeOnly(srcOrEdge);
+        }
+        else {
+            if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
+                if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest)))
+                    return false;
+                if (srcOrEdge instanceof AbstractVertex)
+                    srcOrEdge = srcOrEdge.id;
+                if (dest instanceof AbstractVertex)
+                    dest = dest.id;
+                var newEdge = this.createEdge(srcOrEdge, dest, weight, val);
+                return this._addEdgeOnly(newEdge);
+            }
+            else {
+                throw new Error('dest must be a Vertex or vertex id while srcOrEdge is an Edge');
+            }
+        }
     };
     /**
      * The function sets the weight of an edge between two vertices in a graph.
@@ -891,12 +893,6 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
     };
-    /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -939,11 +935,6 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { costs: costs, predecessor: predecessor };
     };
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * 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
@@ -1071,6 +1062,37 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
     };
+    /**
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
+     */
+    AbstractGraph.prototype._addVertexOnly = function (newVertex) {
+        if (this.hasVertex(newVertex)) {
+            return false;
+            // throw (new Error('Duplicated vertex id is not allowed'));
+        }
+        this._vertices.set(newVertex.id, newVertex);
+        return true;
+    };
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     */
+    AbstractGraph.prototype._getVertex = function (vertexOrId) {
+        var vertexId = this._getVertexId(vertexOrId);
+        return this._vertices.get(vertexId) || null;
+    };
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
+     */
+    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
+        return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
+    };
     /**--- start find cycles --- */
     AbstractGraph.prototype._setVertices = function (value) {
         this._vertices = value;

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

@@ -44,7 +44,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @param id
      * @param val
      */
-    _createVertex(id: VertexId, val?: V['val']): V;
+    createVertex(id: VertexId, val?: V['val']): 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.
@@ -53,7 +53,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @param weight
      * @param val
      */
-    _createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+    createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
     /**
      * The function `getEdge` returns the directed edge between two vertices, given their source and destination.
      * @param {V | null | VertexId} srcOrId - The source vertex or its ID. It can be either a
@@ -63,14 +63,6 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @returns a E object or null.
      */
     getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
-    /**
-     * The `addEdge` function adds a directed edge to a graph if the source and destination vertices exist.
-     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
-     * contains two properties:
-     * @returns The method `addEdge` returns a boolean value. It returns `true` if the edge was successfully added to the
-     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
-     */
-    addEdge(edge: E): boolean;
     /**
      * The `removeEdgeBetween` function removes an edge between two vertices in a directed graph and returns the removed
      * edge, or null if the edge was not found.
@@ -81,7 +73,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if it exists, or `null` if
      * the edge does not exist.
      */
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     /**
      * The `removeEdge` function removes a directed edge from a graph and returns the removed edge, or null if the edge was
      * not found.
@@ -92,13 +84,14 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      */
     removeEdge(edge: E): E | null;
     /**
-     * The function removeAllEdges removes all edges between two vertices.
-     * @param {VertexId | V} src - The `src` parameter can be either a `VertexId` or a `V`.
-     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It
-     * can be either a `VertexId` or a `V`.
-     * @returns An empty array of DirectedEdge objects is being returned.
+     * The function removes all edges between two vertices and returns the removed edges.
+     * @param {VertexId | V} v1 - The parameter `v1` represents either a `VertexId` or a `V` object. It is used to identify
+     * the first vertex in the graph.
+     * @param {VertexId | V} v2 - The parameter `v2` represents either a `VertexId` or a `V`. It is used to identify the
+     * second vertex involved in the edges that need to be removed.
+     * @returns The function `removeEdgesBetween` returns an array of removed edges (`E[]`).
      */
-    removeAllEdges(src: VertexId | V, dest: VertexId | V): E[];
+    removeEdgesBetween(v1: VertexId | V, v2: VertexId | V): E[];
     /**
      * The function returns an array of incoming edges of a given vertex or vertex ID.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`
@@ -163,18 +156,19 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      */
     getDestinations(vertex: V | VertexId | null): V[];
     /**
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of `V` or `VertexId` objects in
-     * topological order, or `null` if there is a cycle in the graph.
+     * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
+     * in the sorted order, or null if the graph contains a cycle.
+     * @param {'vertex' | 'id'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'id'. If 'vertex' is
+     * specified, the vertices themselves will be used for sorting. If 'id' is specified, the ids of
+     * @returns an array of vertices or vertex IDs in topological order, or null if there is a cycle in the graph.
      */
-    topologicalSort(): Array<V | VertexId> | null;
+    topologicalSort(propertyName?: 'vertex' | 'id'): Array<V | VertexId> | null;
     /**
      * The `edgeSet` function returns an array of all directed edges in the graph.
      * @returns The `edgeSet()` method returns an array of `E` objects.
      */
     edgeSet(): E[];
-    /**--- start find cycles --- */
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in a directed graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`
@@ -182,7 +176,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @returns an array of DirectedVertex objects.
      */
     getNeighbors(vertexOrId: V | VertexId): V[];
-    /**--- end find cycles --- */
+    /**--- start find cycles --- */
     /**
      * The function "getEndsOfEdge" returns the source and destination vertices of a directed edge if it exists in the
      * graph, otherwise it returns null.
@@ -191,6 +185,15 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * not exist in the graph.
      */
     getEndsOfEdge(edge: E): [V, V] | null;
+    /**--- end find cycles --- */
+    /**
+     * The `_addEdgeOnly` function adds a directed edge to a graph if the source and destination vertices exist.
+     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
+     * contains two properties:
+     * @returns The method `_addEdgeOnly` returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
+     */
+    protected _addEdgeOnly(edge: E): boolean;
     protected _setOutEdgeMap(value: Map<V, E[]>): void;
     protected _setInEdgeMap(value: Map<V, E[]>): void;
 }

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

@@ -148,7 +148,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param id
      * @param val
      */
-    DirectedGraph.prototype._createVertex = function (id, val) {
+    DirectedGraph.prototype.createVertex = function (id, val) {
         return new DirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
@@ -159,7 +159,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param weight
      * @param val
      */
-    DirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
+    DirectedGraph.prototype.createEdge = function (src, dest, weight, val) {
         return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
@@ -184,41 +184,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         return edges[0] || null;
     };
-    /**
-     * The `addEdge` function adds a directed edge to a graph if the source and destination vertices exist.
-     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
-     * contains two properties:
-     * @returns The method `addEdge` returns a boolean value. It returns `true` if the edge was successfully added to the
-     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
-     */
-    DirectedGraph.prototype.addEdge = function (edge) {
-        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
-            return false;
-        }
-        var srcVertex = this._getVertex(edge.src);
-        var destVertex = this._getVertex(edge.dest);
-        // TODO after no-non-null-assertion not ensure the logic
-        if (srcVertex && destVertex) {
-            var srcOutEdges = this._outEdgeMap.get(srcVertex);
-            if (srcOutEdges) {
-                srcOutEdges.push(edge);
-            }
-            else {
-                this._outEdgeMap.set(srcVertex, [edge]);
-            }
-            var destInEdges = this._inEdgeMap.get(destVertex);
-            if (destInEdges) {
-                destInEdges.push(edge);
-            }
-            else {
-                this._inEdgeMap.set(destVertex, [edge]);
-            }
-            return true;
-        }
-        else {
-            return false;
-        }
-    };
     /**
      * The `removeEdgeBetween` function removes an edge between two vertices in a directed graph and returns the removed
      * edge, or null if the edge was not found.
@@ -229,7 +194,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if it exists, or `null` if
      * the edge does not exist.
      */
-    DirectedGraph.prototype.removeEdgeBetween = function (srcOrId, destOrId) {
+    DirectedGraph.prototype.removeEdgeSrcToDest = function (srcOrId, destOrId) {
         var src = this._getVertex(srcOrId);
         var dest = this._getVertex(destOrId);
         var removed = null;
@@ -238,14 +203,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         var srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            /**
-             * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
-             * found.
-             * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
-             * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
-             * respectively.
-             * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
-             */
             (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.dest === dest.id; });
         }
         var destInEdges = this._inEdgeMap.get(dest);
@@ -279,14 +236,22 @@ var DirectedGraph = /** @class */ (function (_super) {
         return removed;
     };
     /**
-     * The function removeAllEdges removes all edges between two vertices.
-     * @param {VertexId | V} src - The `src` parameter can be either a `VertexId` or a `V`.
-     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It
-     * can be either a `VertexId` or a `V`.
-     * @returns An empty array of DirectedEdge objects is being returned.
+     * The function removes all edges between two vertices and returns the removed edges.
+     * @param {VertexId | V} v1 - The parameter `v1` represents either a `VertexId` or a `V` object. It is used to identify
+     * the first vertex in the graph.
+     * @param {VertexId | V} v2 - The parameter `v2` represents either a `VertexId` or a `V`. It is used to identify the
+     * second vertex involved in the edges that need to be removed.
+     * @returns The function `removeEdgesBetween` returns an array of removed edges (`E[]`).
      */
-    DirectedGraph.prototype.removeAllEdges = function (src, dest) {
-        return [];
+    DirectedGraph.prototype.removeEdgesBetween = function (v1, v2) {
+        var removed = [];
+        if (v1 && v2) {
+            var v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
+            var v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+            v1ToV2 && removed.push(v1ToV2);
+            v2ToV1 && removed.push(v2ToV1);
+        }
+        return removed;
     };
     /**
      * The function returns an array of incoming edges of a given vertex or vertex ID.
@@ -400,14 +365,17 @@ var DirectedGraph = /** @class */ (function (_super) {
         return destinations;
     };
     /**
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of `V` or `VertexId` objects in
-     * topological order, or `null` if there is a cycle in the graph.
+     * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
+     * in the sorted order, or null if the graph contains a cycle.
+     * @param {'vertex' | 'id'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'id'. If 'vertex' is
+     * specified, the vertices themselves will be used for sorting. If 'id' is specified, the ids of
+     * @returns an array of vertices or vertex IDs in topological order, or null if there is a cycle in the graph.
      */
-    DirectedGraph.prototype.topologicalSort = function () {
+    DirectedGraph.prototype.topologicalSort = function (propertyName) {
         var e_2, _a, e_3, _b;
         var _this = this;
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
         var statusMap = new Map();
@@ -469,6 +437,8 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         if (hasCycle)
             return null;
+        if (propertyName === 'id')
+            sorted = sorted.map(function (vertex) { return vertex instanceof DirectedVertex ? vertex.id : vertex; });
         return sorted.reverse();
     };
     /**
@@ -482,7 +452,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         });
         return edges;
     };
-    /**--- start find cycles --- */
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in a directed graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`
@@ -515,7 +484,7 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         return neighbors;
     };
-    /**--- end find cycles --- */
+    /**--- start find cycles --- */
     /**
      * The function "getEndsOfEdge" returns the source and destination vertices of a directed edge if it exists in the
      * graph, otherwise it returns null.
@@ -536,6 +505,42 @@ var DirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    /**--- end find cycles --- */
+    /**
+     * The `_addEdgeOnly` function adds a directed edge to a graph if the source and destination vertices exist.
+     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
+     * contains two properties:
+     * @returns The method `_addEdgeOnly` returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
+     */
+    DirectedGraph.prototype._addEdgeOnly = function (edge) {
+        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
+            return false;
+        }
+        var srcVertex = this._getVertex(edge.src);
+        var destVertex = this._getVertex(edge.dest);
+        // TODO after no-non-null-assertion not ensure the logic
+        if (srcVertex && destVertex) {
+            var srcOutEdges = this._outEdgeMap.get(srcVertex);
+            if (srcOutEdges) {
+                srcOutEdges.push(edge);
+            }
+            else {
+                this._outEdgeMap.set(srcVertex, [edge]);
+            }
+            var destInEdges = this._inEdgeMap.get(destVertex);
+            if (destInEdges) {
+                destInEdges.push(edge);
+            }
+            else {
+                this._inEdgeMap.set(destVertex, [edge]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
     DirectedGraph.prototype._setOutEdgeMap = function (value) {
         this._outEdgeMap = value;
     };