data-structure-typed 1.17.4 → 1.18.5

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -33,22 +33,23 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * The function creates a new BSTNode with the given id, value, and count.
      * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    TreeMultiSet.prototype.createNode = function (id, val, count) {
-        return new bst_1.BSTNode(id, val, count);
+    TreeMultiSet.prototype._createNode = function (id, val, count) {
+        var node = new bst_1.BSTNode(id, val, count);
+        return node;
     };
     /**
      * The function overrides the add method of the BinarySearchTree class in TypeScript.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
+     * can be of type `N` (the generic type) or `null`.
      * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
      * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<T>` object or `null`.
+     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
      */
     TreeMultiSet.prototype.add = function (id, val, count) {
         return _super.prototype.add.call(this, id, val, count);

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

@@ -1,57 +1,50 @@
-import type { DijkstraResult, IGraph, VertexId } from '../types';
-export declare class AbstractVertex {
-    constructor(id: VertexId);
-    protected _id: VertexId;
+import type { DijkstraResult, VertexId } from '../types';
+import { IGraph } from '../interfaces';
+export declare abstract class AbstractVertex<T = number> {
+    protected constructor(id: VertexId, val?: T);
+    private _id;
     get id(): VertexId;
     set id(v: VertexId);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getId(): VertexId;
+    private _val;
+    get val(): T | undefined;
+    set val(value: T | undefined);
 }
-export declare abstract class AbstractEdge {
-    static DEFAULT_EDGE_WEIGHT: number;
-    /**
-     * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
-     * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
-     */
-    protected constructor(weight?: number);
+export declare abstract class AbstractEdge<T = number> {
+    protected constructor(weight?: number, val?: T);
+    private _val;
+    get val(): T | undefined;
+    set val(value: T | undefined);
     private _weight;
     get weight(): number;
     set weight(v: number);
-    private _hashCode;
+    protected _hashCode: string;
     get hashCode(): string;
-    set hashCode(v: string);
+    protected _setHashCode(v: string): void;
+}
+export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IGraph<V, E> {
+    private _vertices;
+    get vertices(): Map<VertexId, V>;
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * 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.
+     * @param id
+     * @param val
      */
-    getWeight(): number;
+    abstract _createVertex(id: VertexId, val?: V): V;
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * 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.
+     * @param srcOrV1
+     * @param destOrV2
+     * @param weight
+     * @param val
      */
-    getHashCode(): string;
-}
-export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
-    protected _vertices: Map<VertexId, V>;
+    abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
     abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     abstract removeEdge(edge: E): E | null;
-    /**
-     * The function `getVertex` returns the vertex object associated with a given vertex ID or vertex object, or null if it
-     * does not exist.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns The function `getVertex` returns the vertex object (`V`) corresponding to the given `vertexOrId` parameter.
-     * If the vertex is found in the `_vertices` map, it is returned. Otherwise, `null` is returned.
-     */
-    getVertex(vertexOrId: VertexId | V): V | null;
-    /**
-     * The function `getVertexId` returns the id of a vertex, whether it is passed as an instance of `AbstractVertex` or as
-     * a `VertexId`.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns the id of the vertex.
-     */
-    getVertexId(vertexOrId: V | VertexId): VertexId;
+    _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
@@ -59,18 +52,8 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * @returns The method `hasVertex` returns a boolean value.
      */
     hasVertex(vertexOrId: V | VertexId): boolean;
-    /**
-     * The function `vertexSet()` returns a map of vertices.
-     * @returns The method `vertexSet()` returns a map of vertex IDs to vertex objects.
-     */
-    vertexSet(): Map<VertexId, V>;
-    abstract getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
-    /**
-     * The addVertex function adds a new vertex to a graph if it does not already exist.
-     * @param {V} newVertex - The parameter "newVertex" is of type V, which represents a vertex in a graph.
-     * @returns The method is returning a boolean value. If the newVertex is already contained in the graph, it will return
-     * false. Otherwise, it will add the newVertex to the graph and return true.
-     */
+    abstract getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    createAddVertex(id: VertexId, val?: V['val']): boolean;
     addVertex(newVertex: V): boolean;
     /**
      * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
@@ -100,6 +83,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * 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;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
@@ -176,15 +160,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<V>`.
      */
     dijkstraWithoutHeap(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.
-     */
     /**
      * 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.
@@ -204,13 +179,16 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * @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>;
-    abstract getEndsOfEdge(edge: E): [V, V] | null;
     /**
-     * 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
+     * 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.
+     */
+    abstract getEndsOfEdge(edge: E): [V, V] | null;
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
@@ -236,9 +214,10 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
         minPath: V[];
     };
     /**
-     * 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.
+     * 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
@@ -255,7 +234,11 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
         costs: number[][];
         predecessor: (V | null)[][];
     };
-    /**--- start find cycles --- */
+    /**
+     * 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
@@ -285,4 +268,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
         SCCs: Map<number, V[]>;
         cycles: Map<number, V[]>;
     };
+    /**--- start find cycles --- */
+    protected _setVertices(value: Map<VertexId, V>): void;
 }

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

@@ -47,8 +47,9 @@ exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 var utils_1 = require("../../utils");
 var priority_queue_1 = require("../priority-queue");
 var AbstractVertex = /** @class */ (function () {
-    function AbstractVertex(id) {
+    function AbstractVertex(id, val) {
         this._id = id;
+        this._val = val;
     }
     Object.defineProperty(AbstractVertex.prototype, "id", {
         get: function () {
@@ -60,27 +61,35 @@ var AbstractVertex = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractVertex.prototype.getId = function () {
-        return this._id;
-    };
+    Object.defineProperty(AbstractVertex.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (value) {
+            this._val = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     return AbstractVertex;
 }());
 exports.AbstractVertex = AbstractVertex;
 var AbstractEdge = /** @class */ (function () {
-    /**
-     * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
-     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
-     * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
-     */
-    function AbstractEdge(weight) {
-        if (weight === undefined)
-            weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
-        this._weight = weight;
+    function AbstractEdge(weight, val) {
+        this._weight = weight !== undefined ? weight : 1;
+        this._val = val;
         this._hashCode = (0, utils_1.uuidV4)();
     }
+    Object.defineProperty(AbstractEdge.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (value) {
+            this._val = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AbstractEdge.prototype, "weight", {
         get: function () {
             return this._weight;
@@ -95,25 +104,21 @@ var AbstractEdge = /** @class */ (function () {
         get: function () {
             return this._hashCode;
         },
-        set: function (v) {
-            this._hashCode = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractEdge.prototype.getWeight = function () {
-        return this._weight;
+    // /**
+    //  * 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.
+    //  * @param srcOrV1
+    //  * @param destOrV2
+    //  * @param weight
+    //  * @param val
+    //  */
+    // abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
+    AbstractEdge.prototype._setHashCode = function (v) {
+        this._hashCode = v;
     };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    AbstractEdge.prototype.getHashCode = function () {
-        return this._hashCode;
-    };
-    AbstractEdge.DEFAULT_EDGE_WEIGHT = 1;
     return AbstractEdge;
 }());
 exports.AbstractEdge = AbstractEdge;
@@ -125,25 +130,21 @@ var AbstractGraph = /** @class */ (function () {
         /**--- end find cycles --- */
         // Minimum Spanning Tree
     }
-    /**
-     * The function `getVertex` returns the vertex object associated with a given vertex ID or vertex object, or null if it
-     * does not exist.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
-     * @returns The function `getVertex` returns the vertex object (`V`) corresponding to the given `vertexOrId` parameter.
-     * If the vertex is found in the `_vertices` map, it is returned. Otherwise, `null` is returned.
-     */
-    AbstractGraph.prototype.getVertex = function (vertexOrId) {
-        var vertexId = this.getVertexId(vertexOrId);
+    Object.defineProperty(AbstractGraph.prototype, "vertices", {
+        get: function () {
+            return this._vertices;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AbstractGraph.prototype._getVertex = function (vertexOrId) {
+        var vertexId = this._getVertexId(vertexOrId);
         return this._vertices.get(vertexId) || null;
     };
-    /**
-     * The function `getVertexId` returns the id of a vertex, whether it is passed as an instance of `AbstractVertex` or as
-     * a `VertexId`.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
-     * (`VertexId`).
-     * @returns the id of the vertex.
-     */
-    AbstractGraph.prototype.getVertexId = function (vertexOrId) {
+    AbstractGraph.prototype.getVertex = function (vertexId) {
+        return this._vertices.get(vertexId) || null;
+    };
+    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
         return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
     };
     /**
@@ -153,24 +154,16 @@ var AbstractGraph = /** @class */ (function () {
      * @returns The method `hasVertex` returns a boolean value.
      */
     AbstractGraph.prototype.hasVertex = function (vertexOrId) {
-        return this._vertices.has(this.getVertexId(vertexOrId));
+        return this._vertices.has(this._getVertexId(vertexOrId));
     };
-    /**
-     * The function `vertexSet()` returns a map of vertices.
-     * @returns The method `vertexSet()` returns a map of vertex IDs to vertex objects.
-     */
-    AbstractGraph.prototype.vertexSet = function () {
-        return this._vertices;
+    AbstractGraph.prototype.createAddVertex = function (id, val) {
+        var newVertex = this._createVertex(id, val);
+        return this.addVertex(newVertex);
     };
-    /**
-     * The addVertex function adds a new vertex to a graph if it does not already exist.
-     * @param {V} newVertex - The parameter "newVertex" is of type V, which represents a vertex in a graph.
-     * @returns The method is returning a boolean value. If the newVertex is already contained in the graph, it will return
-     * false. Otherwise, it will add the newVertex to the graph and return true.
-     */
     AbstractGraph.prototype.addVertex = 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;
@@ -182,7 +175,7 @@ var AbstractGraph = /** @class */ (function () {
      * @returns The method `removeVertex` returns a boolean value.
      */
     AbstractGraph.prototype.removeVertex = function (vertexOrId) {
-        var vertexId = this.getVertexId(vertexOrId);
+        var vertexId = this._getVertexId(vertexOrId);
         return this._vertices.delete(vertexId);
     };
     /**
@@ -223,6 +216,14 @@ 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);
+    };
     /**
      * 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
@@ -256,8 +257,8 @@ var AbstractGraph = /** @class */ (function () {
     AbstractGraph.prototype.getAllPathsBetween = function (v1, v2) {
         var _this = this;
         var paths = [];
-        var vertex1 = this.getVertex(v1);
-        var vertex2 = this.getVertex(v2);
+        var vertex1 = this._getVertex(v1);
+        var vertex2 = this._getVertex(v2);
         if (!(vertex1 && vertex2)) {
             return [];
         }
@@ -344,8 +345,8 @@ var AbstractGraph = /** @class */ (function () {
         }
         else {
             // BFS
-            var vertex2 = this.getVertex(v2);
-            var vertex1 = this.getVertex(v1);
+            var vertex2 = this._getVertex(v2);
+            var vertex1 = this._getVertex(v1);
             if (!(vertex1 && vertex2)) {
                 return null;
             }
@@ -430,8 +431,8 @@ var AbstractGraph = /** @class */ (function () {
         else {
             // BFS
             var minPath_1 = [];
-            var vertex1_1 = this.getVertex(v1);
-            var vertex2 = this.getVertex(v2);
+            var vertex1_1 = this._getVertex(v1);
+            var vertex2 = this._getVertex(v2);
             if (!(vertex1_1 && vertex2)) {
                 return [];
             }
@@ -502,8 +503,8 @@ var AbstractGraph = /** @class */ (function () {
         var distMap = new Map();
         var seen = new Set();
         var preMap = new Map(); // predecessor
-        var srcVertex = this.getVertex(src);
-        var destVertex = dest ? this.getVertex(dest) : null;
+        var srcVertex = this._getVertex(src);
+        var destVertex = dest ? this._getVertex(dest) : null;
         if (!srcVertex) {
             return null;
         }
@@ -630,15 +631,6 @@ var AbstractGraph = /** @class */ (function () {
         genPaths && getPaths(minDest);
         return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, minPath: minPath };
     };
-    /**
-     * 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.
-     */
     /**
      * 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.
@@ -674,8 +666,8 @@ var AbstractGraph = /** @class */ (function () {
         var distMap = new Map();
         var seen = new Set();
         var preMap = new Map(); // predecessor
-        var srcVertex = this.getVertex(src);
-        var destVertex = dest ? this.getVertex(dest) : null;
+        var srcVertex = this._getVertex(src);
+        var destVertex = dest ? this._getVertex(dest) : null;
         if (!srcVertex) {
             return null;
         }
@@ -787,12 +779,6 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { distMap: distMap, preMap: preMap, seen: seen, paths: paths, minDist: minDist, 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
-     */
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
@@ -815,7 +801,7 @@ var AbstractGraph = /** @class */ (function () {
             getMin = false;
         if (genPath === undefined)
             genPath = false;
-        var srcVertex = this.getVertex(src);
+        var srcVertex = this._getVertex(src);
         var paths = [];
         var distMap = new Map();
         var preMap = new Map(); // predecessor
@@ -906,9 +892,10 @@ var AbstractGraph = /** @class */ (function () {
         return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
     };
     /**
-     * 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.
+     * 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
@@ -952,7 +939,11 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { costs: costs, predecessor: predecessor };
     };
-    /**--- start find cycles --- */
+    /**
+     * 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
@@ -1080,6 +1071,10 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
     };
+    /**--- start find cycles --- */
+    AbstractGraph.prototype._setVertices = function (value) {
+        this._vertices = value;
+    };
     return AbstractGraph;
 }());
 exports.AbstractGraph = AbstractGraph;