data-structure-typed 1.12.21 → 1.15.1

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

@@ -73,6 +73,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getId = function () {
+        return this._id;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "val", {
         get: function () {
             return this._val;
@@ -83,6 +89,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getVal = function () {
+        return this._val;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "left", {
         get: function () {
             return this._left;
@@ -97,6 +109,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getLeft = function () {
+        return this._left;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "right", {
         get: function () {
             return this._right;
@@ -111,6 +129,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getRight = function () {
+        return this._right;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "parent", {
         get: function () {
             return this._parent;
@@ -121,6 +145,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getParent = function () {
+        return this._parent;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "familyPosition", {
         get: function () {
             return this._familyPosition;
@@ -131,6 +161,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getFamilyPosition = function () {
+        return this._familyPosition;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "count", {
         get: function () {
             return this._count;
@@ -141,6 +177,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getCount = function () {
+        return this._count;
+    };
     Object.defineProperty(BinaryTreeNode.prototype, "height", {
         get: function () {
             return this._height;
@@ -151,6 +193,12 @@ var BinaryTreeNode = /** @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.
+     */
+    BinaryTreeNode.prototype.getHeight = function () {
+        return this._height;
+    };
     BinaryTreeNode.prototype.swapLocation = function (swapNode) {
         var val = swapNode.val, count = swapNode.count, height = swapNode.height;
         var tempNode = new BinaryTreeNode(swapNode.id, val);
@@ -213,6 +261,13 @@ var BinaryTree = /** @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 Getters (using the same name as the property) while utilizing separate method names for Setters.
+     * @returns The method is returning either a BinaryTreeNode object of type T or null.
+     */
+    BinaryTree.prototype.getRoot = function () {
+        return this._root;
+    };
     Object.defineProperty(BinaryTree.prototype, "size", {
         get: function () {
             return this._size;
@@ -223,6 +278,12 @@ var BinaryTree = /** @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.
+     */
+    BinaryTree.prototype.getSize = function () {
+        return this._size;
+    };
     Object.defineProperty(BinaryTree.prototype, "count", {
         get: function () {
             return this._count;
@@ -233,6 +294,12 @@ var BinaryTree = /** @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.
+     */
+    BinaryTree.prototype.getCount = function () {
+        return this._count;
+    };
     /**
      * The function creates a new binary tree node with the given id, value, and count, or returns null if the value is
      * null.

package/dist/data-structures/binary-tree/segment-tree.d.ts

@@ -10,21 +10,45 @@ export declare class SegmentTreeNode {
     constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
     protected _start: number;
     get start(): 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.
+     */
+    getStart(): number;
     set start(v: number);
     protected _end: number;
     get end(): 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.
+     */
+    getEnd(): number;
     set end(v: number);
     protected _val: SegmentTreeNodeVal | null;
     get val(): SegmentTreeNodeVal | null;
+    /**
+     * 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.
+     */
+    getVal(): SegmentTreeNodeVal | null;
     set val(v: SegmentTreeNodeVal | null);
     protected _sum: number;
     get sum(): 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.
+     */
+    getSum(): number;
     set sum(v: number);
     protected _left: SegmentTreeNode | null;
     get left(): SegmentTreeNode | null;
+    /**
+     * 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.
+     */
+    getLeft(): SegmentTreeNode | null;
     set left(v: SegmentTreeNode | null);
     protected _right: SegmentTreeNode | null;
     get right(): SegmentTreeNode | null;
+    /**
+     * 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.
+     */
+    getRight(): SegmentTreeNode | null;
     set right(v: SegmentTreeNode | null);
 }
 export declare class SegmentTree {
@@ -43,6 +67,11 @@ export declare class SegmentTree {
     constructor(values: number[], start?: number, end?: number);
     protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
+    /**
+     * 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.
+     */
+    getRoot(): SegmentTreeNode | null;
+    set root(v: SegmentTreeNode | null);
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.

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

@@ -31,6 +31,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getStart = function () {
+        return this._start;
+    };
     Object.defineProperty(SegmentTreeNode.prototype, "end", {
         get: function () {
             return this._end;
@@ -41,6 +47,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getEnd = function () {
+        return this._end;
+    };
     Object.defineProperty(SegmentTreeNode.prototype, "val", {
         get: function () {
             return this._val;
@@ -51,6 +63,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getVal = function () {
+        return this._val;
+    };
     Object.defineProperty(SegmentTreeNode.prototype, "sum", {
         get: function () {
             return this._sum;
@@ -61,6 +79,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getSum = function () {
+        return this._sum;
+    };
     Object.defineProperty(SegmentTreeNode.prototype, "left", {
         get: function () {
             return this._left;
@@ -71,6 +95,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getLeft = function () {
+        return this._left;
+    };
     Object.defineProperty(SegmentTreeNode.prototype, "right", {
         get: function () {
             return this._right;
@@ -81,6 +111,12 @@ var SegmentTreeNode = /** @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.
+     */
+    SegmentTreeNode.prototype.getRight = function () {
+        return this._right;
+    };
     return SegmentTreeNode;
 }());
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -108,9 +144,18 @@ var SegmentTree = /** @class */ (function () {
         get: function () {
             return this._root;
         },
+        set: function (v) {
+            this._root = 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.
+     */
+    SegmentTree.prototype.getRoot = function () {
+        return this._root;
+    };
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.

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

@@ -1,9 +1,13 @@
 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;
@@ -15,9 +19,17 @@ export declare abstract class AbstractEdge {
     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> {
@@ -44,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.
@@ -84,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.
@@ -164,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
@@ -186,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
@@ -209,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

@@ -60,6 +60,12 @@ 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;
@@ -85,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;
@@ -95,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;
 }());
@@ -103,8 +121,7 @@ exports.AbstractEdge = AbstractEdge;
 var AbstractGraph = /** @class */ (function () {
     function AbstractGraph() {
         this._vertices = new Map();
-        // unionFind() {
-        // }
+        // unionFind() {}
         /**--- end find cycles --- */
         // Minimum Spanning Tree
     }
@@ -133,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));
     };
     /**
@@ -152,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);
@@ -199,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;
     };
@@ -613,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
@@ -763,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
@@ -874,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

@@ -21,9 +21,17 @@ export declare class DirectedEdge extends AbstractEdge {
     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> {

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

@@ -101,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;
@@ -111,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;
@@ -153,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);
@@ -482,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

@@ -20,10 +20,20 @@ export declare class UndirectedEdge extends AbstractEdge {
     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.