data-structure-typed 1.12.11 → 1.15.0

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

@@ -17,8 +17,11 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var bst_1 = require("./bst");
 var TreeMultiSet = /** @class */ (function (_super) {
@@ -26,12 +29,40 @@ var TreeMultiSet = /** @class */ (function (_super) {
     function TreeMultiSet() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * 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 {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.put = function (id, val, count) {
-        return _super.prototype.put.call(this, id, val, count);
+    /**
+     * 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 {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`.
+     */
+    TreeMultiSet.prototype.add = function (id, val, count) {
+        return _super.prototype.add.call(this, id, val, count);
     };
+    /**
+     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
+     * method.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * removed from the tree.
+     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
+     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
+     * set to `true`, the left sum of all nodes will be recalculated. If it
+     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
+     */
     TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
         return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
     };

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

@@ -1,18 +1,35 @@
 import type { DijkstraResult, IGraph, VertexId } from '../types';
 export declare class AbstractVertex {
-    constructor(id: VertexId);
     protected _id: VertexId;
     get id(): 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;
     set id(v: VertexId);
+    constructor(id: VertexId);
 }
 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);
     private _weight;
     get weight(): number;
+    /**
+     * 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.
+     */
+    getWeight(): number;
     set weight(v: number);
     private _hashCode;
     get hashCode(): string;
+    /**
+     * 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.
+     */
+    getHashCode(): string;
     set hashCode(v: string);
 }
 export declare abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
@@ -39,9 +56,9 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * 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
      * (`VertexId`).
-     * @returns The method `containsVertex` returns a boolean value.
+     * @returns The method `hasVertex` returns a boolean value.
      */
-    containsVertex(vertexOrId: V | VertexId): boolean;
+    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.
@@ -79,10 +96,10 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
      * a vertex in a graph, while V represents the type of the vertex itself.
      * @param {VertexId | V} v2 - The parameter `v2` represents the second vertex in an edge. It can be either a `VertexId`
      * or a `V` type.
-     * @returns The function `containsEdge` returns a boolean value. It returns `true` if there is an edge between the
+     * @returns The function `hasEdge` returns a boolean value. It returns `true` if there is an edge between the
      * vertices `v1` and `v2`, and `false` otherwise.
      */
-    containsEdge(v1: VertexId | V, v2: VertexId | V): boolean;
+    hasEdge(v1: VertexId | V, v2: VertexId | V): boolean;
     abstract addEdge(edge: E): boolean;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
@@ -159,8 +176,18 @@ 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.
      * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {V | VertexId} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
@@ -181,6 +208,13 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
     /**
      * 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
+     * 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
      * all other vertices in a graph, and optionally detects negative cycles and generates the minimum path.
      * @param {V | VertexId} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
@@ -204,6 +238,12 @@ export declare abstract class AbstractGraph<V extends AbstractVertex, E extends
     /**
      * 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.
+     */
+    /**
+     * 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.
      * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
      * graph.
      * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`

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

@@ -38,8 +38,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var utils_1 = require("../../utils");
 var priority_queue_1 = require("../priority-queue");
@@ -57,10 +60,21 @@ 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;
+    };
     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;
@@ -77,6 +91,12 @@ var AbstractEdge = /** @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.
+     */
+    AbstractEdge.prototype.getWeight = function () {
+        return this._weight;
+    };
     Object.defineProperty(AbstractEdge.prototype, "hashCode", {
         get: function () {
             return this._hashCode;
@@ -87,6 +107,12 @@ var AbstractEdge = /** @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.
+     */
+    AbstractEdge.prototype.getHashCode = function () {
+        return this._hashCode;
+    };
     AbstractEdge.DEFAULT_EDGE_WEIGHT = 1;
     return AbstractEdge;
 }());
@@ -95,8 +121,7 @@ exports.AbstractEdge = AbstractEdge;
 var AbstractGraph = /** @class */ (function () {
     function AbstractGraph() {
         this._vertices = new Map();
-        // unionFind() {
-        // }
+        // unionFind() {}
         /**--- end find cycles --- */
         // Minimum Spanning Tree
     }
@@ -125,9 +150,9 @@ var AbstractGraph = /** @class */ (function () {
      * 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
      * (`VertexId`).
-     * @returns The method `containsVertex` returns a boolean value.
+     * @returns The method `hasVertex` returns a boolean value.
      */
-    AbstractGraph.prototype.containsVertex = function (vertexOrId) {
+    AbstractGraph.prototype.hasVertex = function (vertexOrId) {
         return this._vertices.has(this.getVertexId(vertexOrId));
     };
     /**
@@ -144,7 +169,7 @@ var AbstractGraph = /** @class */ (function () {
      * false. Otherwise, it will add the newVertex to the graph and return true.
      */
     AbstractGraph.prototype.addVertex = function (newVertex) {
-        if (this.containsVertex(newVertex)) {
+        if (this.hasVertex(newVertex)) {
             return false;
         }
         this._vertices.set(newVertex.id, newVertex);
@@ -191,10 +216,10 @@ var AbstractGraph = /** @class */ (function () {
      * a vertex in a graph, while V represents the type of the vertex itself.
      * @param {VertexId | V} v2 - The parameter `v2` represents the second vertex in an edge. It can be either a `VertexId`
      * or a `V` type.
-     * @returns The function `containsEdge` returns a boolean value. It returns `true` if there is an edge between the
+     * @returns The function `hasEdge` returns a boolean value. It returns `true` if there is an edge between the
      * vertices `v1` and `v2`, and `false` otherwise.
      */
-    AbstractGraph.prototype.containsEdge = function (v1, v2) {
+    AbstractGraph.prototype.hasEdge = function (v1, v2) {
         var edge = this.getEdge(v1, v2);
         return !!edge;
     };
@@ -605,8 +630,18 @@ 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.
      * The `dijkstra` function implements Dijkstra's algorithm to find the shortest path between a source vertex and an
      * optional destination vertex, and optionally returns the minimum distance, the paths, and other information.
      * @param {V | VertexId} src - The `src` parameter represents the source vertex from which the Dijkstra algorithm will
@@ -660,7 +695,7 @@ var AbstractGraph = /** @class */ (function () {
             finally { if (e_11) throw e_11.error; }
         }
         var heap = new priority_queue_1.PriorityQueue({ comparator: function (a, b) { return a.id - b.id; } });
-        heap.offer({ id: 0, val: srcVertex });
+        heap.add({ id: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
         var getPaths = function (minV) {
@@ -717,7 +752,7 @@ var AbstractGraph = /** @class */ (function () {
                                     var distSrcToNeighbor = distMap.get(neighbor);
                                     if (distSrcToNeighbor) {
                                         if (dist + weight < distSrcToNeighbor) {
-                                            heap.offer({ id: dist + weight, val: neighbor });
+                                            heap.add({ id: dist + weight, val: neighbor });
                                             preMap.set(neighbor, cur);
                                             distMap.set(neighbor, dist + weight);
                                         }
@@ -755,6 +790,13 @@ var AbstractGraph = /** @class */ (function () {
     /**
      * 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
+     * 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
      * all other vertices in a graph, and optionally detects negative cycles and generates the minimum path.
      * @param {V | VertexId} src - The `src` parameter is the source vertex from which the Bellman-Ford algorithm will
@@ -866,6 +908,12 @@ var AbstractGraph = /** @class */ (function () {
     /**
      * 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.
+     */
+    /**
+     * 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.
      * The function implements the Floyd-Warshall algorithm to find the shortest path between all pairs of vertices in a
      * graph.
      * @returns The function `floyd()` returns an object with two properties: `costs` and `predecessor`. The `costs`

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

@@ -1,15 +1,37 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { IDirectedGraph, VertexId } from '../types';
 export declare class DirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId);
 }
 export declare class DirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes the source and destination vertices of an edge, with an optional weight.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex. It represents the vertex
+     * to which an edge is directed.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(src: VertexId, dest: VertexId, weight?: number);
     private _src;
     get src(): 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.
+     */
+    getSrc(): VertexId;
     set src(v: VertexId);
     private _dest;
     get dest(): 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.
+     */
+    getDest(): VertexId;
     set dest(v: VertexId);
 }
 export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
@@ -123,10 +145,10 @@ export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedE
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
-     * 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 vertices in topological order if there is no cycle in
-     * the graph. If there is a cycle in the graph, it returns `null`.
+     * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
+     * order, or null if the graph contains a cycle.
+     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
+     * cycle in the graph. If there is a cycle, it returns `null`.
      */
     topologicalSort(): V[] | null;
     /**--- end find cycles --- */

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

@@ -53,13 +53,21 @@ var __values = (this && this.__values) || function(o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var utils_1 = require("../../utils");
 var abstract_graph_1 = require("./abstract-graph");
 var DirectedVertex = /** @class */ (function (_super) {
     __extends(DirectedVertex, _super);
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     function DirectedVertex(id) {
         return _super.call(this, id) || this;
     }
@@ -68,6 +76,15 @@ var DirectedVertex = /** @class */ (function (_super) {
 exports.DirectedVertex = DirectedVertex;
 var DirectedEdge = /** @class */ (function (_super) {
     __extends(DirectedEdge, _super);
+    /**
+     * The constructor function initializes the source and destination vertices of an edge, with an optional weight.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex. It represents the vertex
+     * to which an edge is directed.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     function DirectedEdge(src, dest, weight) {
         var _this = _super.call(this, weight) || this;
         _this._src = src;
@@ -84,6 +101,12 @@ var DirectedEdge = /** @class */ (function (_super) {
         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.
+     */
+    DirectedEdge.prototype.getSrc = function () {
+        return this._src;
+    };
     Object.defineProperty(DirectedEdge.prototype, "dest", {
         get: function () {
             return this._dest;
@@ -94,6 +117,12 @@ var DirectedEdge = /** @class */ (function (_super) {
         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.
+     */
+    DirectedEdge.prototype.getDest = function () {
+        return this._dest;
+    };
     return DirectedEdge;
 }(abstract_graph_1.AbstractEdge));
 exports.DirectedEdge = DirectedEdge;
@@ -136,7 +165,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
      */
     DirectedGraph.prototype.addEdge = function (edge) {
-        if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
+        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
             return false;
         }
         var srcVertex = this.getVertex(edge.src);
@@ -342,43 +371,14 @@ var DirectedGraph = /** @class */ (function (_super) {
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
-     * 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 vertices in topological order if there is no cycle in
-     * the graph. If there is a cycle in the graph, it returns `null`.
+     * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
+     * order, or null if the graph contains a cycle.
+     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
+     * cycle in the graph. If there is a cycle, it returns `null`.
      */
     DirectedGraph.prototype.topologicalSort = function () {
         var e_2, _a, e_3, _b;
         var _this = this;
-        // vector<vector<int>> g;
-        // vector<int> color;
-        // int last;
-        // bool hasCycle;
-        //
-        // bool topo_sort() {
-        //     int n = g.size();
-        //     vector<int> degree(n, 0);
-        //     queue<int> q;
-        //     for (int i = 0; i < n; i++) {
-        //         degree[i] = g[i].size();
-        //         if (degree[i] <= 1) {
-        //             q.push(i);
-        //         }
-        //     }
-        //     int cnt = 0;
-        //     while (!q.empty()) {
-        //         cnt++;
-        //         int root = q.front();
-        //         q.pop();
-        //         for (auto child : g[root]) {
-        //             degree[child]--;
-        //             if (degree[child] == 1) {
-        //                 q.push(child);
-        //             }
-        //         }
-        //     }
-        //     return (cnt != n);
-        // }
         // 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();
@@ -438,9 +438,8 @@ var DirectedGraph = /** @class */ (function (_super) {
             }
             finally { if (e_3) throw e_3.error; }
         }
-        if (hasCycle) {
+        if (hasCycle)
             return null;
-        }
         return sorted.reverse();
     };
     /**--- end find cycles --- */
@@ -495,7 +494,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * returns null.
      */
     DirectedGraph.prototype.getEndsOfEdge = function (edge) {
-        if (!this.containsEdge(edge.src, edge.dest)) {
+        if (!this.hasEdge(edge.src, edge.dest)) {
             return null;
         }
         var v1 = this.getVertex(edge.src);

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

@@ -1,16 +1,39 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../types';
 export declare class UndirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId);
 }
 export declare class UndirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
+     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * graph.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(v1: VertexId, v2: VertexId, weight?: number);
     private _vertices;
     get vertices(): [VertexId, 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.
+     */
+    getVertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);
 }
 export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
     protected _edges: Map<V, E[]>;
+    get edges(): Map<V, E[]>;
+    /**
+     * 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.
+     */
+    getEdges(): Map<V, E[]>;
+    protected set edges(v: Map<V, E[]>);
     constructor();
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.

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

@@ -53,13 +53,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var utils_1 = require("../../utils");
 var abstract_graph_1 = require("./abstract-graph");
 var UndirectedVertex = /** @class */ (function (_super) {
     __extends(UndirectedVertex, _super);
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     function UndirectedVertex(id) {
         return _super.call(this, id) || this;
     }
@@ -68,6 +76,14 @@ var UndirectedVertex = /** @class */ (function (_super) {
 exports.UndirectedVertex = UndirectedVertex;
 var UndirectedEdge = /** @class */ (function (_super) {
     __extends(UndirectedEdge, _super);
+    /**
+     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
+     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * graph.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     function UndirectedEdge(v1, v2, weight) {
         var _this = _super.call(this, weight) || this;
         _this._vertices = [v1, v2];
@@ -83,6 +99,12 @@ var UndirectedEdge = /** @class */ (function (_super) {
         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.
+     */
+    UndirectedEdge.prototype.getVertices = function () {
+        return this._vertices;
+    };
     return UndirectedEdge;
 }(abstract_graph_1.AbstractEdge));
 exports.UndirectedEdge = UndirectedEdge;
@@ -93,6 +115,22 @@ var UndirectedGraph = /** @class */ (function (_super) {
         _this._edges = new Map();
         return _this;
     }
+    Object.defineProperty(UndirectedGraph.prototype, "edges", {
+        get: function () {
+            return this._edges;
+        },
+        set: function (v) {
+            this._edges = 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.
+     */
+    UndirectedGraph.prototype.getEdges = function () {
+        return this._edges;
+    };
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
      * @param {V | null | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID
@@ -277,7 +315,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * `null`.
      */
     UndirectedGraph.prototype.getEndsOfEdge = function (edge) {
-        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
+        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
             return null;
         }
         var v1 = this.getVertex(edge.vertices[0]);