data-structure-typed 1.18.6 → 1.18.7

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

@@ -7,13 +7,24 @@
  */
 import { BST, BSTNode } from './bst';
 import type { BinaryTreeNodeId, RecursiveTreeMultiSetNode, TreeMultiSetOptions } from '../types';
-import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
+import { IBST, IBSTNode } from '../interfaces';
+export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
+    /**
+     * The function creates a new node in a binary tree with an optional value and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
+     * meaning it can be omitted when calling the `createNode` method.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
+     */
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 /**
  * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBinaryTree<N> {
+export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBST<N> {
     constructor(options?: TreeMultiSetOptions);
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -24,5 +35,5 @@ export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<numbe
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    _createNode(id: BinaryTreeNodeId, val: N['val'], count?: number): N;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -40,6 +40,19 @@ var TreeMultiSetNode = /** @class */ (function (_super) {
     function TreeMultiSetNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function creates a new node in a binary tree with an optional value and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the tree.
+     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
+     * meaning it can be omitted when calling the `createNode` method.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
+     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
+     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
+     */
+    TreeMultiSetNode.prototype.createNode = function (id, val, count) {
+        return new TreeMultiSetNode(id, (val === undefined ? id : val), count);
+    };
     return TreeMultiSetNode;
 }(bst_1.BSTNode));
 exports.TreeMultiSetNode = TreeMultiSetNode;
@@ -60,9 +73,8 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    TreeMultiSet.prototype._createNode = function (id, val, count) {
-        var node = new TreeMultiSetNode(id, val, count);
-        return node;
+    TreeMultiSet.prototype.createNode = function (id, val, count) {
+        return new TreeMultiSetNode(id, val === undefined ? id : val, count);
     };
     return TreeMultiSet;
 }(bst_1.BST));

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

@@ -44,7 +44,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @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.
@@ -53,7 +53,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @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
@@ -81,7 +81,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @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.
@@ -92,13 +92,14 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      */
     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

@@ -148,7 +148,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param id
      * @param val
      */
-    DirectedGraph.prototype._createVertex = function (id, val) {
+    DirectedGraph.prototype.createVertex = function (id, val) {
         return new DirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
@@ -159,7 +159,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param weight
      * @param val
      */
-    DirectedGraph.prototype._createEdge = function (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);
     };
     /**
@@ -229,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;
@@ -238,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);
@@ -279,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,7 +27,7 @@ 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> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, 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[]>;
@@ -36,9 +37,9 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @param id
      * @param val
      */
-    _createVertex(id: VertexId, val?: V['val']): V;
+    createVertex(id: VertexId, val?: V['val']): V;
     /**
-     * The function _createEdge creates an undirected edge between two vertices with an optional weight and value.
+     * 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
@@ -49,7 +50,7 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * is used to store additional information or data associated with the edge.
      * @returns an instance of the UndirectedEdge class, casted as type E.
      */
-    _createEdge(v1: VertexId, v2: 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.
@@ -105,13 +106,6 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @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

@@ -126,11 +126,11 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * @param id
      * @param val
      */
-    UndirectedGraph.prototype._createVertex = function (id, val) {
+    UndirectedGraph.prototype.createVertex = function (id, val) {
         return new UndirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
-     * The function _createEdge creates an undirected edge between two vertices with an optional weight and value.
+     * 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
@@ -141,7 +141,7 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * 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 (v1, v2, weight, val) {
+    UndirectedGraph.prototype.createEdge = function (v1, v2, weight, val) {
         return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
@@ -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;
+}