data-structure-typed 1.12.21 → 1.15.0

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -7,7 +7,13 @@
  */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
-    protected nodes: T[];
+    protected _nodes: T[];
+    get nodes(): T[];
+    /**
+     * 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.
+     */
+    getNodes(): T[];
+    protected set nodes(value: T[]);
     /**
      * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
      * function.

package/dist/data-structures/priority-queue/priority-queue.js

@@ -44,7 +44,7 @@ var PriorityQueue = /** @class */ (function () {
      * @param options - The `options` parameter is an object that contains the following properties:
      */
     function PriorityQueue(options) {
-        this.nodes = [];
+        this._nodes = [];
         this._comparator = function (a, b) {
             var aKey = a, bKey = b;
             return aKey - bKey;
@@ -53,10 +53,26 @@ var PriorityQueue = /** @class */ (function () {
         this._comparator = comparator;
         if (nodes && nodes instanceof Array && nodes.length > 0) {
             // TODO support distinct
-            this.nodes = Array.isArray(nodes) ? __spreadArray([], __read(nodes), false) : [];
+            this._nodes = Array.isArray(nodes) ? __spreadArray([], __read(nodes), false) : [];
             isFix && this._fix();
         }
     }
+    Object.defineProperty(PriorityQueue.prototype, "nodes", {
+        get: function () {
+            return this._nodes;
+        },
+        set: function (value) {
+            this._nodes = value;
+        },
+        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.
+     */
+    PriorityQueue.prototype.getNodes = function () {
+        return this._nodes;
+    };
     Object.defineProperty(PriorityQueue.prototype, "size", {
         get: function () {
             return this.nodes.length;

package/dist/data-structures/queue/deque.d.ts

@@ -9,15 +9,26 @@ import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
 export declare class ObjectDeque<T> {
-    protected _nodes: {
-        [key: number]: T;
+    private _nodes;
+    get nodes(): {
+        [p: number]: T;
     };
-    protected _capacity: number;
-    protected _first: number;
-    protected _last: number;
-    protected _size: number;
+    protected set nodes(value: {
+        [p: number]: T;
+    });
+    private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
+    private _first;
+    get first(): number;
+    set first(value: number);
+    private _last;
+    get last(): number;
+    set last(value: number);
+    private _size;
+    get size(): number;
+    protected set size(value: number);
     constructor(capacity?: number);
-    size(): number;
     addFirst(value: T): void;
     addLast(value: T): void;
     pollFirst(): T | undefined;

package/dist/data-structures/queue/deque.js

@@ -47,9 +47,56 @@ var ObjectDeque = /** @class */ (function () {
         if (capacity !== undefined)
             this._capacity = capacity;
     }
-    ObjectDeque.prototype.size = function () {
-        return this._size;
-    };
+    Object.defineProperty(ObjectDeque.prototype, "nodes", {
+        get: function () {
+            return this._nodes;
+        },
+        set: function (value) {
+            this._nodes = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "capacity", {
+        get: function () {
+            return this._capacity;
+        },
+        set: function (value) {
+            this._capacity = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "first", {
+        get: function () {
+            return this._first;
+        },
+        set: function (value) {
+            this._first = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "last", {
+        get: function () {
+            return this._last;
+        },
+        set: function (value) {
+            this._last = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ObjectDeque.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        set: function (value) {
+            this._size = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     ObjectDeque.prototype.addFirst = function (value) {
         if (this._size === 0) {
             var mid = Math.floor(this._capacity / 2);

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

@@ -8,7 +8,7 @@ export type DijkstraResult<V> = {
     minPath: V[];
 } | null;
 export interface IGraph<V, E> {
-    containsVertex(vertexOrId: V | VertexId): boolean;
+    hasVertex(vertexOrId: V | VertexId): boolean;
     getVertex(vertexOrId: VertexId | V): V | null;
     getVertexId(vertexOrId: V | VertexId): VertexId;
     vertexSet(): Map<VertexId, V>;
@@ -17,7 +17,7 @@ export interface IGraph<V, E> {
     removeAllVertices(vertices: V[] | VertexId[]): boolean;
     degreeOf(vertexOrId: V | VertexId): number;
     edgesOf(vertexOrId: V | VertexId): E[];
-    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
+    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
     getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     edgeSet(): E[];
     addEdge(edge: E): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.12.21",
+  "version": "1.15.0",
   "description": "Explore our comprehensive Javascript Data Structure / TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
@@ -54,7 +54,7 @@
     "jest": "^29.6.2",
     "ts-jest": "^29.1.1",
     "typedoc": "^0.24.8",
-    "typescript": "^4.6.2"
+    "typescript": "^4.9.5"
   },
   "dependencies": {
     "lodash": "^4.17.21"

package/src/data-structures/binary-tree/aa-tree.ts

@@ -1,3 +1,3 @@
 export class AaTree {
 
-}
+}

package/src/data-structures/binary-tree/binary-tree.ts

@@ -30,38 +30,50 @@ export enum LoopType { iterative = 1, recursive = 2}
 
 export class BinaryTreeNode<T> {
 
-    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
-        this._id = id;
-        this._val = val;
-        this._count = count ?? 1;
-    }
-
     protected _id: BinaryTreeNodeId;
-
     get id(): BinaryTreeNodeId {
         return this._id;
     }
 
+    /**
+     * 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(): BinaryTreeNodeId {
+        return this._id;
+    }
+
     set id(v: BinaryTreeNodeId) {
         this._id = v;
     }
 
     protected _val: T;
-
     get val(): T {
         return this._val;
     }
 
+    /**
+     * 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(): T {
+        return this._val;
+    }
+
     set val(v: T) {
         this._val = v;
     }
 
     protected _left?: BinaryTreeNode<T> | null;
-
     get left(): BinaryTreeNode<T> | null | undefined {
         return this._left;
     }
 
+    /**
+     * 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(): BinaryTreeNode<T> | null | undefined {
+        return this._left;
+    }
+
     set left(v: BinaryTreeNode<T> | null | undefined) {
         if (v) {
             v.parent = this;
@@ -71,11 +83,17 @@ export class BinaryTreeNode<T> {
     }
 
     protected _right?: BinaryTreeNode<T> | null;
-
     get right(): BinaryTreeNode<T> | null | undefined {
         return this._right;
     }
 
+    /**
+     * 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(): BinaryTreeNode<T> | null | undefined {
+        return this._right;
+    }
+
     set right(v: BinaryTreeNode<T> | null | undefined) {
         if (v) {
             v.parent = this;
@@ -85,45 +103,75 @@ export class BinaryTreeNode<T> {
     }
 
     protected _parent: BinaryTreeNode<T> | null | undefined;
-
     get parent(): BinaryTreeNode<T> | null | undefined {
         return this._parent;
     }
 
+    /**
+     * 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.
+     */
+    getParent(): BinaryTreeNode<T> | null | undefined {
+        return this._parent;
+    }
+
     set parent(v: BinaryTreeNode<T> | null | undefined) {
         this._parent = v;
     }
 
     protected _familyPosition: FamilyPosition = FamilyPosition.root;
-
     get familyPosition(): FamilyPosition {
         return this._familyPosition;
     }
 
+    /**
+     * 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.
+     */
+    getFamilyPosition(): FamilyPosition {
+        return this._familyPosition;
+    }
+
     set familyPosition(v: FamilyPosition) {
         this._familyPosition = v;
     }
 
     protected _count = 1;
-
     get count(): number {
         return this._count;
     }
 
+    /**
+     * 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.
+     */
+    getCount(): number {
+        return this._count;
+    }
+
     set count(v: number) {
         this._count = v;
     }
 
     protected _height = 0;
-
     get height(): number {
         return this._height;
     }
 
+    /**
+     * 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.
+     */
+    getHeight(): number {
+        return this._height;
+    }
+
     set height(v: number) {
         this._height = v;
     }
 
+    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
+        this._id = id;
+        this._val = val;
+        this._count = count ?? 1;
+    }
+
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T> {
         const {val, count, height} = swapNode;
         const tempNode = new BinaryTreeNode<T>(swapNode.id, val);
@@ -187,6 +235,14 @@ export class BinaryTree<T> {
         return this._root;
     }
 
+    /**
+     * 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.
+     */
+    getRoot(): BinaryTreeNode<T> | null {
+        return this._root;
+    }
+
     protected set root(v: BinaryTreeNode<T> | null) {
         if (v) {
             v.parent = null;
@@ -201,6 +257,13 @@ export class BinaryTree<T> {
         return this._size;
     }
 
+    /**
+     * 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.
+     */
+    getSize(): number {
+        return this._size;
+    }
+
     protected set size(v: number) {
         this._size = v;
     }
@@ -211,6 +274,13 @@ export class BinaryTree<T> {
         return this._count;
     }
 
+    /**
+     * 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.
+     */
+    getCount(): number {
+        return this._count;
+    }
+
     protected set count(v: number) {
         this._count = v;
     }

package/src/data-structures/binary-tree/segment-tree.ts

@@ -17,61 +17,85 @@ export class SegmentTreeNode {
     }
 
     protected _start = 0;
-
     get start(): number {
         return this._start;
     }
-
+    /**
+     * 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 {
+        return this._start;
+    }
     set start(v: number) {
         this._start = v;
     }
 
     protected _end = 0;
-
     get end(): number {
         return this._end;
     }
-
+    /**
+     * 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 {
+        return this._end;
+    }
     set end(v: number) {
         this._end = v;
     }
 
     protected _val: SegmentTreeNodeVal | null = null;
-
     get val(): SegmentTreeNodeVal | null {
         return this._val;
     }
-
+    /**
+     * 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 {
+        return this._val;
+    }
     set val(v: SegmentTreeNodeVal | null) {
         this._val = v;
     }
 
     protected _sum = 0;
-
     get sum(): number {
         return this._sum;
     }
-
+    /**
+     * 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 {
+        return this._sum;
+    }
     set sum(v: number) {
         this._sum = v;
     }
 
     protected _left: SegmentTreeNode | null = null;
-
     get left(): SegmentTreeNode | null {
         return this._left;
     }
-
+    /**
+     * 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 {
+        return this._left;
+    }
     set left(v: SegmentTreeNode | null) {
         this._left = v;
     }
 
     protected _right: SegmentTreeNode | null = null;
-
     get right(): SegmentTreeNode | null {
         return this._right;
     }
-
+    /**
+     * 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 {
+        return this._right;
+    }
     set right(v: SegmentTreeNode | null) {
         this._right = v;
     }
@@ -101,10 +125,18 @@ export class SegmentTree {
     }
 
     protected _root: SegmentTreeNode | null;
-
     get root(): SegmentTreeNode | null {
         return this._root;
     }
+    /**
+     * 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 {
+        return this._root;
+    }
+    set root(v: SegmentTreeNode | null) {
+        this._root = v;
+    }
 
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes

package/src/data-structures/graph/abstract-graph.ts

@@ -10,19 +10,25 @@ import {PriorityQueue} from '../priority-queue';
 import type {DijkstraResult, IGraph, VertexId} from '../types';
 
 export class AbstractVertex {
-    constructor(id: VertexId) {
-        this._id = id;
-    }
-
     protected _id: VertexId;
+    get id(): VertexId {
+        return this._id;
+    }
 
-    public 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 {
         return this._id;
     }
 
-    public set id(v: VertexId) {
+    set id(v: VertexId) {
         this._id = v;
     }
+
+    constructor(id: VertexId) {
+        this._id = id;
+    }
 }
 
 export abstract class AbstractEdge {
@@ -41,21 +47,33 @@ export abstract class AbstractEdge {
     }
 
     private _weight: number;
-
     get weight(): number {
         return this._weight;
     }
 
+    /**
+     * 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 {
+        return this._weight;
+    }
+
     set weight(v: number) {
         this._weight = v;
     }
 
     private _hashCode: string;
-
     get hashCode(): string {
         return this._hashCode;
     }
 
+    /**
+     * 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 {
+        return this._hashCode;
+    }
+
     set hashCode(v: string) {
         this._hashCode = v;
     }
@@ -97,9 +115,9 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
      * 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 {
         return this._vertices.has(this.getVertexId(vertexOrId));
     }
 
@@ -120,7 +138,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
      * false. Otherwise, it will add the newVertex to the graph and return true.
      */
     addVertex(newVertex: V): boolean {
-        if (this.containsVertex(newVertex)) {
+        if (this.hasVertex(newVertex)) {
             return false;
         }
         this._vertices.set(newVertex.id, newVertex);
@@ -165,10 +183,10 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
      * 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 {
         const edge = this.getEdge(v1, v2);
         return !!edge;
     }
@@ -499,8 +517,20 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         return {distMap, preMap, seen, paths, minDist, 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
@@ -625,10 +655,17 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
 
     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
+     */
 
     /**
      * 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
@@ -732,6 +769,13 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
     /**
      * 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`
@@ -903,8 +947,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
     }
 
 
-    // unionFind() {
-    // }
+    // unionFind() {}
 
     /**--- end find cycles --- */