data-structure-typed 1.12.11 → 1.15.0

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 --- */
 

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

@@ -40,17 +40,26 @@ export class DirectedEdge extends AbstractEdge {
     get src(): VertexId {
         return this._src;
     }
-
+    /**
+     * 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 {
+        return this._src;
+    }
     set src(v: VertexId) {
         this._src = v;
     }
 
-
     private _dest: VertexId;
     get dest(): VertexId {
         return this._dest;
     }
-
+    /**
+     * 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 {
+        return this._dest;
+    }
     set dest(v: VertexId) {
         this._dest = v;
     }
@@ -101,7 +110,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * graph, and `false` if either the source or destination vertices of the edge are not present in the graph.
      */
     addEdge(edge: E): boolean {
-        if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
+        if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
             return false;
         }
 
@@ -401,7 +410,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * returns null.
      */
     getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.src, edge.dest)) {
+        if (!this.hasEdge(edge.src, edge.dest)) {
             return null;
         }
         const v1 = this.getVertex(edge.src);

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

@@ -35,21 +35,38 @@ export class UndirectedEdge extends AbstractEdge {
     }
 
     private _vertices: [VertexId, VertexId];
-
-    public get vertices() {
+    get vertices() {
         return this._vertices;
     }
-
-    public set vertices(v: [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() {
+        return this._vertices;
+    }
+    set vertices(v: [VertexId, VertexId]) {
         this._vertices = v;
     }
 }
 
 export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    protected _edges: Map<V, E[]> = new Map();
+    protected _edges: Map<V, E[]>;
+    get edges(): Map<V, E[]> {
+        return this._edges;
+    }
+    /**
+     * 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[]> {
+        return this._edges;
+    }
+    protected set edges(v: Map<V, E[]>) {
+        this._edges = v;
+    }
 
     constructor() {
         super();
+        this._edges = new Map<V, E[]>();
     }
 
     /**
@@ -223,7 +240,7 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
      * `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | null {
-        if (!this.containsEdge(edge.vertices[0], edge.vertices[1])) {
+        if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
             return null;
         }
         const v1 = this.getVertex(edge.vertices[0]);

package/src/data-structures/hash/coordinate-map.ts

@@ -6,7 +6,19 @@
  * @license MIT License
  */
 export class CoordinateMap<V> extends Map<any, V> {
-    private readonly _joint: string = '_';
+    protected _joint: string = '_';
+    get joint(): string {
+        return this._joint;
+    }
+    /**
+     * 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.
+     */
+    getJoint(): string {
+        return this._joint;
+    }
+    protected set joint(v: string) {
+        this._joint = v;
+    }
 
     constructor(joint?: string) {
         super();

package/src/data-structures/hash/coordinate-set.ts

@@ -6,7 +6,19 @@
  * @license MIT License
  */
 export class CoordinateSet extends Set {
-    private readonly _joint: string = '_';
+    protected _joint: string = '_';
+    get joint(): string {
+        return this._joint;
+    }
+    /**
+     * 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.
+     */
+    getJoint(): string {
+        return this._joint;
+    }
+    protected set joint(v: string) {
+        this._joint = v;
+    }
 
     constructor(joint?: string) {
         super();

package/src/data-structures/heap/heap.ts

@@ -10,7 +10,32 @@ import type {HeapItem, HeapOptions} from '../types';
 
 export abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
+    get pq() {
+        return this._pq;
+    }
+    /**
+     * 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.
+     */
+    getPq() {
+        return this._pq;
+    }
+    protected set pq(v: PriorityQueue<HeapItem<T>>) {
+        this._pq = v;
+    }
+
     protected _priorityCb: (element: T) => number;
+    get priorityCb() {
+        return this._priorityCb;
+    }
+    /**
+     * 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.
+     */
+    getPriorityCb() {
+        return this._priorityCb;
+    }
+    protected set priorityCb(v: (element: T) => number) {
+        this._priorityCb = v;
+    }
 
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
@@ -36,6 +61,12 @@ export abstract class Heap<T> {
     get size(): number {
         return this._pq.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._pq.size;
+    }
 
     /**
      * The function checks if a priority queue is empty.

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -8,29 +8,86 @@
 import type {DoublyLinkedListGetBy} from '../types';
 
 export class DoublyLinkedListNode<T> {
-    val: T;
-    next: DoublyLinkedListNode<T> | null;
-    prev: DoublyLinkedListNode<T> | null;
+    protected _val: T;
+    get val(): T {
+        return this._val;
+    }
+    set val(v: T) {
+        this._val = v;
+    }
+
+    protected _next: DoublyLinkedListNode<T> | null;
+    get next(): DoublyLinkedListNode<T> | null {
+        return this._next;
+    }
+    set next(v: DoublyLinkedListNode<T> | null) {
+        this._next = v;
+    }
+
+    protected _prev: DoublyLinkedListNode<T> | null;
+    get prev(): DoublyLinkedListNode<T> | null {
+        return this._prev;
+    }
+    set prev(v: DoublyLinkedListNode<T> | null) {
+        this._prev = v;
+    }
 
     constructor(nodeValue: T) {
-        this.val = nodeValue;
-        this.next = null;
-        this.prev = null;
+        this._val = nodeValue;
+        this._next = null;
+        this._prev = null;
     }
 }
 
 export class DoublyLinkedList<T> {
-    private _first: DoublyLinkedListNode<T> | null = null;
-    private _last: DoublyLinkedListNode<T> | null = null;
-    private _size = 0;
+    protected _first: DoublyLinkedListNode<T> | null;
+    get first(): DoublyLinkedListNode<T> | null {
+        return this._first;
+    }
+    /**
+     * 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.
+     */
+    getFirst(): DoublyLinkedListNode<T> | null {
+        return this._first;
+    }
+    protected set first(v: DoublyLinkedListNode<T> | null) {
+        this._first = v;
+    }
+
+    protected _last: DoublyLinkedListNode<T> | null;
+    get last(): DoublyLinkedListNode<T> | null {
+        return this._last;
+    }
+    /**
+     * 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.
+     */
+    getLast(): DoublyLinkedListNode<T> | null {
+        return this._last;
+    }
+    protected set last(v: DoublyLinkedListNode<T> | null) {
+        this._last = v;
+    }
+
+    protected _size: number;
     get size(): number {
         return this._size;
     }
-
-    set size(v: 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.
+     */
+    getSize(): number {
+        return this._size;
+    }
+    protected set size(v: number) {
         this._size = v;
     }
 
+    constructor() {
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+    }
+
     /**
      * The function adds a new node with a given value to the beginning of a doubly linked list.
      * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of