data-structure-typed 1.18.5 → 1.18.7

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

@@ -1,5 +1,5 @@
 import type { DijkstraResult, VertexId } from '../types';
-import { IGraph } from '../interfaces';
+import { IAbstractGraph } from '../interfaces';
 export declare abstract class AbstractVertex<T = number> {
     protected constructor(id: VertexId, val?: T);
     private _id;
@@ -21,7 +21,7 @@ export declare abstract class AbstractEdge<T = number> {
     get hashCode(): string;
     protected _setHashCode(v: string): void;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IGraph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IAbstractGraph<V, E> {
     private _vertices;
     get vertices(): Map<VertexId, V>;
     /**
@@ -30,7 +30,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @param id
      * @param val
      */
-    abstract _createVertex(id: VertexId, val?: V): V;
+    abstract createVertex(id: VertexId, val?: V): V;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -39,12 +39,9 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @param weight
      * @param val
      */
-    abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
-    abstract removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    abstract createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
     abstract removeEdge(edge: E): E | null;
-    _getVertex(vertexOrId: VertexId | V): V | null;
     getVertex(vertexId: VertexId): V | null;
-    _getVertexId(vertexOrId: V | VertexId): VertexId;
     /**
      * The function checks if a vertex exists in a graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can accept either a vertex object (`V`) or a vertex ID
@@ -179,11 +176,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<V>`.
      */
     dijkstra(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
-    /**
-     * 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.
@@ -214,10 +206,9 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         minPath: V[];
     };
     /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
      */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
@@ -234,11 +225,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         costs: number[][];
         predecessor: (V | null)[][];
     };
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
@@ -268,6 +254,19 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         SCCs: Map<number, V[]>;
         cycles: Map<number, V[]>;
     };
+    /**
+     * 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
+     */
+    protected _getVertex(vertexOrId: VertexId | V): V | null;
+    /**
+     * 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.
+     */
+    protected _getVertexId(vertexOrId: V | VertexId): VertexId;
     /**--- start find cycles --- */
     protected _setVertices(value: Map<VertexId, V>): void;
 }

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

@@ -115,7 +115,7 @@ var AbstractEdge = /** @class */ (function () {
     //  * @param weight
     //  * @param val
     //  */
-    // abstract _createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
+    // abstract createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
     AbstractEdge.prototype._setHashCode = function (v) {
         this._hashCode = v;
     };
@@ -137,16 +137,9 @@ var AbstractGraph = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    AbstractGraph.prototype._getVertex = function (vertexOrId) {
-        var vertexId = this._getVertexId(vertexOrId);
-        return this._vertices.get(vertexId) || null;
-    };
     AbstractGraph.prototype.getVertex = function (vertexId) {
         return this._vertices.get(vertexId) || null;
     };
-    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
-        return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
-    };
     /**
      * 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
@@ -157,7 +150,7 @@ var AbstractGraph = /** @class */ (function () {
         return this._vertices.has(this._getVertexId(vertexOrId));
     };
     AbstractGraph.prototype.createAddVertex = function (id, val) {
-        var newVertex = this._createVertex(id, val);
+        var newVertex = this.createVertex(id, val);
         return this.addVertex(newVertex);
     };
     AbstractGraph.prototype.addVertex = function (newVertex) {
@@ -221,7 +214,7 @@ var AbstractGraph = /** @class */ (function () {
             src = src.id;
         if (dest instanceof AbstractVertex)
             dest = dest.id;
-        var newEdge = this._createEdge(src, dest, weight, val);
+        var newEdge = this.createEdge(src, dest, weight, val);
         return this.addEdge(newEdge);
     };
     /**
@@ -892,10 +885,9 @@ var AbstractGraph = /** @class */ (function () {
         return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
     };
     /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     * 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.
      */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
@@ -939,11 +931,6 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { costs: costs, predecessor: predecessor };
     };
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
@@ -1071,6 +1058,24 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
     };
+    /**
+     * 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
+     */
+    AbstractGraph.prototype._getVertex = function (vertexOrId) {
+        var vertexId = this._getVertexId(vertexOrId);
+        return this._vertices.get(vertexId) || null;
+    };
+    /**
+     * 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.
+     */
+    AbstractGraph.prototype._getVertexId = function (vertexOrId) {
+        return vertexOrId instanceof AbstractVertex ? vertexOrId.id : vertexOrId;
+    };
     /**--- start find cycles --- */
     AbstractGraph.prototype._setVertices = function (value) {
         this._vertices = value;

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

@@ -32,10 +32,8 @@ export declare class DirectedEdge<T = number> extends AbstractEdge<T> {
     get dest(): VertexId;
     set dest(v: VertexId);
 }
-export declare class DirectedGraph<V extends DirectedVertex<any>, E extends DirectedEdge<any>> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
-    private readonly _vertexConstructor;
-    private readonly _edgeConstructor;
-    constructor(vertexConstructor: new (id: VertexId, val?: V['val']) => V, edgeConstructor: new (src: VertexId, dest: VertexId, weight?: number, val?: E['val']) => E);
+export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
+    constructor();
     private _outEdgeMap;
     get outEdgeMap(): Map<V, E[]>;
     private _inEdgeMap;
@@ -46,7 +44,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any>, E extends Dire
      * @param id
      * @param val
      */
-    _createVertex(id: VertexId, val?: V['val']): V;
+    createVertex(id: VertexId, val?: V['val']): V;
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -55,7 +53,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any>, E extends Dire
      * @param weight
      * @param val
      */
-    _createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+    createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
     /**
      * The function `getEdge` returns the directed edge between two vertices, given their source and destination.
      * @param {V | null | VertexId} srcOrId - The source vertex or its ID. It can be either a
@@ -83,7 +81,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any>, E extends Dire
      * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if it exists, or `null` if
      * the edge does not exist.
      */
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     /**
      * The `removeEdge` function removes a directed edge from a graph and returns the removed edge, or null if the edge was
      * not found.
@@ -94,13 +92,14 @@ export declare class DirectedGraph<V extends DirectedVertex<any>, E extends Dire
      */
     removeEdge(edge: E): E | null;
     /**
-     * The function removeAllEdges removes all edges between two vertices.
-     * @param {VertexId | V} src - The `src` parameter can be either a `VertexId` or a `V`.
-     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It
-     * can be either a `VertexId` or a `V`.
-     * @returns An empty array of DirectedEdge objects is being returned.
+     * The function removes all edges between two vertices and returns the removed edges.
+     * @param {VertexId | V} v1 - The parameter `v1` represents either a `VertexId` or a `V` object. It is used to identify
+     * the first vertex in the graph.
+     * @param {VertexId | V} v2 - The parameter `v2` represents either a `VertexId` or a `V`. It is used to identify the
+     * second vertex involved in the edges that need to be removed.
+     * @returns The function `removeEdgesBetween` returns an array of removed edges (`E[]`).
      */
-    removeAllEdges(src: VertexId | V, dest: VertexId | V): E[];
+    removeEdgesBetween(v1: VertexId | V, v2: VertexId | V): E[];
     /**
      * The function returns an array of incoming edges of a given vertex or vertex ID.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`

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

@@ -122,12 +122,10 @@ exports.DirectedEdge = DirectedEdge;
 // Strongly connected, One direction connected, Weakly connected
 var DirectedGraph = /** @class */ (function (_super) {
     __extends(DirectedGraph, _super);
-    function DirectedGraph(vertexConstructor, edgeConstructor) {
+    function DirectedGraph() {
         var _this = _super.call(this) || this;
         _this._outEdgeMap = new Map();
         _this._inEdgeMap = new Map();
-        _this._vertexConstructor = vertexConstructor;
-        _this._edgeConstructor = edgeConstructor;
         return _this;
     }
     Object.defineProperty(DirectedGraph.prototype, "outEdgeMap", {
@@ -150,8 +148,8 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param id
      * @param val
      */
-    DirectedGraph.prototype._createVertex = function (id, val) {
-        return new this._vertexConstructor(id, val);
+    DirectedGraph.prototype.createVertex = function (id, val) {
+        return new DirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -161,10 +159,8 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param weight
      * @param val
      */
-    DirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
-        if (weight === undefined || weight === null)
-            weight = 1;
-        return new this._edgeConstructor(src, dest, weight, val);
+    DirectedGraph.prototype.createEdge = function (src, dest, weight, val) {
+        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
      * The function `getEdge` returns the directed edge between two vertices, given their source and destination.
@@ -233,7 +229,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @returns The function `removeEdgeBetween` returns the removed edge (`E`) if it exists, or `null` if
      * the edge does not exist.
      */
-    DirectedGraph.prototype.removeEdgeBetween = function (srcOrId, destOrId) {
+    DirectedGraph.prototype.removeEdgeSrcToDest = function (srcOrId, destOrId) {
         var src = this._getVertex(srcOrId);
         var dest = this._getVertex(destOrId);
         var removed = null;
@@ -242,14 +238,6 @@ var DirectedGraph = /** @class */ (function (_super) {
         }
         var srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            /**
-             * The removeEdge function removes an edge from a graph and returns the removed edge, or null if the edge was not
-             * found.
-             * @param {E} edge - The `edge` parameter represents the edge that you want to remove from the graph. It should be an
-             * object that has `src` and `dest` properties, which represent the source and destination vertices of the edge,
-             * respectively.
-             * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
-             */
             (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.dest === dest.id; });
         }
         var destInEdges = this._inEdgeMap.get(dest);
@@ -283,14 +271,22 @@ var DirectedGraph = /** @class */ (function (_super) {
         return removed;
     };
     /**
-     * The function removeAllEdges removes all edges between two vertices.
-     * @param {VertexId | V} src - The `src` parameter can be either a `VertexId` or a `V`.
-     * @param {VertexId | V} dest - The `dest` parameter represents the destination vertex of an edge. It
-     * can be either a `VertexId` or a `V`.
-     * @returns An empty array of DirectedEdge objects is being returned.
+     * The function removes all edges between two vertices and returns the removed edges.
+     * @param {VertexId | V} v1 - The parameter `v1` represents either a `VertexId` or a `V` object. It is used to identify
+     * the first vertex in the graph.
+     * @param {VertexId | V} v2 - The parameter `v2` represents either a `VertexId` or a `V`. It is used to identify the
+     * second vertex involved in the edges that need to be removed.
+     * @returns The function `removeEdgesBetween` returns an array of removed edges (`E[]`).
      */
-    DirectedGraph.prototype.removeAllEdges = function (src, dest) {
-        return [];
+    DirectedGraph.prototype.removeEdgesBetween = function (v1, v2) {
+        var removed = [];
+        if (v1 && v2) {
+            var v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
+            var v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+            v1ToV2 && removed.push(v1ToV2);
+            v2ToV1 && removed.push(v2ToV1);
+        }
+        return removed;
     };
     /**
      * The function returns an array of incoming edges of a given vertex or vertex ID.

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

@@ -1,5 +1,6 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../types';
+import { IUNDirectedGraph } from '../interfaces';
 export declare class UndirectedVertex<T = number> extends AbstractVertex<T> {
     /**
      * The constructor function initializes a vertex with an optional value.
@@ -26,10 +27,8 @@ export declare class UndirectedEdge<T = number> extends AbstractEdge<T> {
     get vertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex<any>, E extends UndirectedEdge<any>> extends AbstractGraph<V, E> {
-    private readonly _vertexConstructor;
-    private readonly _edgeConstructor;
-    constructor(vertexConstructor: new (id: VertexId, val?: V['val']) => V, edgeConstructor: new (src: VertexId, dest: VertexId, weight?: number, val?: E['val']) => E);
+export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IUNDirectedGraph<V, E> {
+    constructor();
     protected _edges: Map<V, E[]>;
     get edges(): Map<V, E[]>;
     /**
@@ -38,16 +37,20 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any>, E extends
      * @param id
      * @param val
      */
-    _createVertex(id: VertexId, val?: V['val']): V;
+    createVertex(id: VertexId, val?: V['val']): V;
     /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     * @param src
-     * @param dest
-     * @param weight
-     * @param val
+     * The function createEdge creates an undirected edge between two vertices with an optional weight and value.
+     * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge. It is of type `VertexId`, which
+     * could be a unique identifier or label for the vertex.
+     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge. It is of type `VertexId`, which
+     * is typically a unique identifier for a vertex in a graph.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
+     * weight is provided, the default value is 1.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * is used to store additional information or data associated with the edge.
+     * @returns an instance of the UndirectedEdge class, casted as type E.
      */
-    _createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+    createEdge(v1: VertexId, v2: VertexId, weight?: number, val?: E['val']): E;
     /**
      * The function `getEdge` returns the first undirected edge that connects two given vertices, or null if no such edge
      * exists.
@@ -103,13 +106,6 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any>, E extends
      * @returns The method `edgeSet()` returns an array of `E` objects.
      */
     edgeSet(): E[];
-    /**
-     * The function "getEdgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either an
-     * `V` object or a `VertexId`.
-     * @returns The function `getEdgesOf` returns an array of `E` objects.
-     */
-    getEdgesOf(vertexOrId: V | VertexId): E[];
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in an undirected graph.
      * @param {V | VertexId} vertexOrId - The `vertexOrId` parameter can be either an

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

@@ -108,10 +108,8 @@ var UndirectedEdge = /** @class */ (function (_super) {
 exports.UndirectedEdge = UndirectedEdge;
 var UndirectedGraph = /** @class */ (function (_super) {
     __extends(UndirectedGraph, _super);
-    function UndirectedGraph(vertexConstructor, edgeConstructor) {
+    function UndirectedGraph() {
         var _this = _super.call(this) || this;
-        _this._vertexConstructor = vertexConstructor;
-        _this._edgeConstructor = edgeConstructor;
         _this._edges = new Map();
         return _this;
     }
@@ -128,21 +126,23 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * @param id
      * @param val
      */
-    UndirectedGraph.prototype._createVertex = function (id, val) {
-        return new this._vertexConstructor(id, val);
+    UndirectedGraph.prototype.createVertex = function (id, val) {
+        return new UndirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     * @param src
-     * @param dest
-     * @param weight
-     * @param val
+     * The function createEdge creates an undirected edge between two vertices with an optional weight and value.
+     * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge. It is of type `VertexId`, which
+     * could be a unique identifier or label for the vertex.
+     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge. It is of type `VertexId`, which
+     * is typically a unique identifier for a vertex in a graph.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
+     * weight is provided, the default value is 1.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * is used to store additional information or data associated with the edge.
+     * @returns an instance of the UndirectedEdge class, casted as type E.
      */
-    UndirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
-        if (weight === undefined || weight === null)
-            weight = 1;
-        return new this._edgeConstructor(src, dest, weight, val);
+    UndirectedGraph.prototype.createEdge = function (v1, v2, weight, val) {
+        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
      * The function `getEdge` returns the first undirected edge that connects two given vertices, or null if no such edge
@@ -280,19 +280,6 @@ var UndirectedGraph = /** @class */ (function (_super) {
         });
         return __spreadArray([], __read(edgeSet), false);
     };
-    /**
-     * The function "getEdgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
-     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either an
-     * `V` object or a `VertexId`.
-     * @returns The function `getEdgesOf` returns an array of `E` objects.
-     */
-    UndirectedGraph.prototype.getEdgesOf = function (vertexOrId) {
-        var vertex = this._getVertex(vertexOrId);
-        if (!vertex) {
-            return [];
-        }
-        return this._edges.get(vertex) || [];
-    };
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in an undirected graph.
      * @param {V | VertexId} vertexOrId - The `vertexOrId` parameter can be either an
@@ -304,7 +291,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
         var neighbors = [];
         var vertex = this._getVertex(vertexOrId);
         if (vertex) {
-            var neighborEdges = this.getEdgesOf(vertex);
+            var neighborEdges = this.edgesOf(vertex);
             try {
                 for (var neighborEdges_1 = __values(neighborEdges), neighborEdges_1_1 = neighborEdges_1.next(); !neighborEdges_1_1.done; neighborEdges_1_1 = neighborEdges_1.next()) {
                     var edge = neighborEdges_1_1.value;

package/dist/data-structures/interfaces/abstract-binary-tree.d.ts

@@ -0,0 +1,101 @@
+import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
+import { AbstractBinaryTreeNode } from '../binary-tree';
+export interface IAbstractBinaryTreeNode<T, FAMILY extends IAbstractBinaryTreeNode<T, FAMILY>> {
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+    get id(): BinaryTreeNodeId;
+    set id(v: BinaryTreeNodeId);
+    get val(): T | undefined;
+    set val(v: T | undefined);
+    get left(): FAMILY | null | undefined;
+    set left(v: FAMILY | null | undefined);
+    get right(): FAMILY | null | undefined;
+    set right(v: FAMILY | null | undefined);
+    get parent(): FAMILY | null | undefined;
+    set parent(v: FAMILY | null | undefined);
+    get familyPosition(): FamilyPosition;
+    set familyPosition(v: FamilyPosition);
+    get count(): number;
+    set count(v: number);
+    get height(): number;
+    set height(v: number);
+    swapLocation(swapNode: FAMILY): FAMILY;
+    clone(): FAMILY | null;
+}
+export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
+    createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    get loopType(): LoopType;
+    get visitedId(): BinaryTreeNodeId[];
+    get visitedVal(): Array<N['val']>;
+    get visitedNode(): N[];
+    get visitedCount(): number[];
+    get visitedLeftSum(): number[];
+    get autoIncrementId(): boolean;
+    get maxId(): number;
+    get isDuplicatedVal(): boolean;
+    get root(): N | null;
+    get size(): number;
+    get count(): number;
+    clear(): void;
+    isEmpty(): boolean;
+    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
+    addTo(newNode: N | null, parent: N): N | null | undefined;
+    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
+    fill(data: N[] | Array<N['val']>): boolean;
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    getDepth(node: N): number;
+    getHeight(beginRoot?: N | null): number;
+    getMinHeight(beginRoot?: N | null): number;
+    isBalanced(beginRoot?: N | null): boolean;
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
+    has(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): boolean;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
+    getPathToRoot(node: N): N[];
+    getLeftMost(): N | null;
+    getLeftMost(node: N): N;
+    getLeftMost(node?: N | null): N | null;
+    getRightMost(): N | null;
+    getRightMost(node: N): N;
+    getRightMost(node?: N | null): N | null;
+    isBSTByRooted(node: N | null): boolean;
+    isBST(node?: N | null): boolean;
+    getSubTreeSizeAndCount(subTreeRoot: N | null | undefined): [number, number];
+    subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
+    subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    BFS(): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+    BFS(nodeOrPropertyName: 'val'): N['val'][];
+    BFS(nodeOrPropertyName: 'node'): N[];
+    BFS(nodeOrPropertyName: 'count'): number[];
+    BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFS(): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    DFSIterative(): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    DFSIterative(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    levelIterative(node: N | null): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
+    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
+    levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    listLevels(node: N | null): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
+    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
+    listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][];
+    getPredecessor(node: N): N;
+    morris(): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,8 +1,6 @@
 import { VertexId } from '../types';
-export interface IGraph<V, E> {
+export interface IAbstractGraph<V, E> {
     hasVertex(vertexOrId: V | VertexId): boolean;
-    _getVertex(vertexOrId: VertexId | V): V | null;
-    _getVertexId(vertexOrId: V | VertexId): VertexId;
     createAddVertex(id: VertexId, val?: V): boolean;
     addVertex(newVertex: V): boolean;
     removeVertex(vertexOrId: V | VertexId): boolean;
@@ -14,7 +12,6 @@ export interface IGraph<V, E> {
     edgeSet(): E[];
     createAddEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
     addEdge(edge: E): boolean;
-    removeEdgeBetween(src: V | VertexId, dest: V | VertexId): E | null;
     removeEdge(edge: E): E | null;
     setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
     getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;

package/dist/data-structures/interfaces/avl-tree.d.ts

@@ -1 +1,16 @@
-export {};
+import { AVLTreeNode } from '../binary-tree';
+import { IBST, IBSTNode } from './bst';
+import { BinaryTreeDeletedResult, BinaryTreeNodeId } from '../types';
+export interface IAVLTreeNode<T, FAMILY extends IAVLTreeNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
+}
+export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
+    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
+    balanceFactor(node: N): number;
+    updateHeight(node: N): void;
+    balancePath(node: N): void;
+    balanceLL(A: N): void;
+    balanceLR(A: N): void;
+    balanceRR(A: N): void;
+    balanceRL(A: N): void;
+}