data-structure-typed 1.18.7 → 1.19.0

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

@@ -14,17 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -50,6 +39,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UndirectedGraph = exports.UndirectedEdge = exports.UndirectedVertex = void 0;
 /**
@@ -65,8 +65,8 @@ var UndirectedVertex = /** @class */ (function (_super) {
     __extends(UndirectedVertex, _super);
     /**
      * The constructor function initializes a vertex with an optional value.
-     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is of type `VertexId`, which is
-     * typically a unique identifier for each vertex in a graph.
+     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
+     * used to uniquely identify the vertex within a graph or network.
      * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to initialize the value of the
      * vertex. If no value is provided, the vertex will be initialized with a default value.
      */
@@ -79,14 +79,14 @@ exports.UndirectedVertex = UndirectedVertex;
 var UndirectedEdge = /** @class */ (function (_super) {
     __extends(UndirectedEdge, _super);
     /**
-     * The constructor function initializes an instance of a class with two vertex IDs, an optional weight, and an optional
+     * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
-     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
+     * @param {VertexId} v1 - The first vertex ID of the edge.
      * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It represents the value associated with
-     * the edge.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store a value associated
+     * with the edge.
      */
     function UndirectedEdge(v1, v2, weight, val) {
         var _this = _super.call(this, weight, val) || this;
@@ -108,6 +108,9 @@ var UndirectedEdge = /** @class */ (function (_super) {
 exports.UndirectedEdge = UndirectedEdge;
 var UndirectedGraph = /** @class */ (function (_super) {
     __extends(UndirectedGraph, _super);
+    /**
+     * The constructor initializes a new Map object to store edges.
+     */
     function UndirectedGraph() {
         var _this = _super.call(this) || this;
         _this._edges = new Map();
@@ -121,37 +124,37 @@ var UndirectedGraph = /** @class */ (function (_super) {
         configurable: true
     });
     /**
-     * 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 id
-     * @param val
+     * The function creates a new vertex with an optional value and returns it.
+     * @param {VertexId} id - The `id` parameter is the unique identifier for the vertex. It is used to distinguish one
+     * vertex from another in the graph.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
+     * it will be used as the value of the vertex. If no value is provided, the `id` parameter will be used as the value of
+     * the vertex.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
      */
     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.
-     * @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.
+     * The function 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.
+     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
+     * no weight is provided, it defaults to 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.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
      */
     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
-     * exists.
-     * @param {V | null | VertexId} v1 - The parameter `v1` represents either an `V`
-     * object, `null`, or a `VertexId`. It is used to specify one of the vertices of the edge.
-     * @param {V | null | VertexId} v2 - The parameter `v2` represents either an `UndirectedVertex`
-     * object or a `VertexId` (identifier) of an undirected vertex.
-     * @returns an instance of `E` or `null`.
+     * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
+     * @param {V | null | VertexId} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexId` (a string or number representing the ID of a vertex).
+     * @param {V | null | VertexId} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * object), `null`, or `VertexId` (vertex ID).
+     * @returns an edge (E) or null.
      */
     UndirectedGraph.prototype.getEdge = function (v1, v2) {
         var _a;
@@ -166,49 +169,11 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return edges ? edges[0] || null : null;
     };
     /**
-     * The function adds an undirected edge to a graph by updating the adjacency list.
-     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
-     * array of two vertices connected by the edge.
-     * @returns a boolean value.
-     */
-    UndirectedGraph.prototype.addEdge = function (edge) {
-        var e_1, _a;
-        try {
-            for (var _b = __values(edge.vertices), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var end = _c.value;
-                var endVertex = this._getVertex(end);
-                if (endVertex === null)
-                    return false;
-                if (endVertex) {
-                    var edges = this._edges.get(endVertex);
-                    if (edges) {
-                        edges.push(edge);
-                    }
-                    else {
-                        this._edges.set(endVertex, [edge]);
-                    }
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return true;
-    };
-    /**
-     * The function removes an edge between two vertices in an undirected graph.
-     * @param {V | VertexId} v1 - The parameter `v1` represents either an `V` object or
-     * a `VertexId`. It is used to specify one of the vertices of the edge that needs to be removed.
-     * @param {V | VertexId} v2 - The parameter `v2` represents either an instance of the
-     * `UndirectedVertex` class or a `VertexId`. It is used to identify the second vertex of the edge that needs to be
-     * removed.
-     * @returns The function `removeEdgeBetween` returns an `E` object if an edge is successfully removed
-     * between the two vertices `v1` and `v2`. If either `v1` or `v2` is not found in the graph, or if there is no edge
-     * between them, the function returns `null`.
+     * The function removes an edge between two vertices in a graph and returns the removed edge.
+     * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
+     * @param {V | VertexId} v2 - V | VertexId - This parameter can be either a vertex object (V) or a vertex ID
+     * (VertexId). It represents the second vertex of the edge that needs to be removed.
+     * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
      */
     UndirectedGraph.prototype.removeEdgeBetween = function (v1, v2) {
         var vertex1 = this._getVertex(v1);
@@ -228,19 +193,19 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return removed;
     };
     /**
-     * The removeEdge function removes an edge between two vertices in an undirected graph.
-     * @param edge - An object representing an undirected edge. It has a property called "vertices" which is an array
-     * containing the two vertices connected by the edge.
-     * @returns The method is returning an UndirectedEdge object or null.
+     * The removeEdge function removes an edge between two vertices in a graph.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
      */
     UndirectedGraph.prototype.removeEdge = function (edge) {
         return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
     };
     /**
-     * The function "degreeOf" returns the degree of a given vertex in an undirected graph.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
-     * `V`.
-     * @returns the degree of the vertex.
+     * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
+     * vertex.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`.
+     * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
+     * edges connected to that vertex.
      */
     UndirectedGraph.prototype.degreeOf = function (vertexOrId) {
         var _a;
@@ -253,10 +218,10 @@ var UndirectedGraph = /** @class */ (function (_super) {
         }
     };
     /**
-     * The function "edgesOf" returns an array of undirected edges connected to a given vertex or vertex ID.
-     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or an
-     * `V`.
-     * @returns an array of UndirectedEdge objects.
+     * The function returns the edges of a given vertex or vertex ID.
+     * @param {VertexId | V} vertexOrId - The parameter `vertexOrId` can be either a `VertexId` or a `V`. A `VertexId` is a
+     * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
+     * @returns an array of edges.
      */
     UndirectedGraph.prototype.edgesOf = function (vertexOrId) {
         var vertex = this._getVertex(vertexOrId);
@@ -268,8 +233,8 @@ var UndirectedGraph = /** @class */ (function (_super) {
         }
     };
     /**
-     * The function "edgeSet" returns an array of unique undirected edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of `E` objects.
+     * The function "edgeSet" returns an array of unique edges from a set of edges.
+     * @returns The method `edgeSet()` returns an array of type `E[]`.
      */
     UndirectedGraph.prototype.edgeSet = function () {
         var edgeSet = new Set();
@@ -281,13 +246,13 @@ var UndirectedGraph = /** @class */ (function (_super) {
         return __spreadArray([], __read(edgeSet), false);
     };
     /**
-     * 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
-     * `V` object or a `VertexId`. It represents the vertex for which we want to find the neighbors.
-     * @returns an array of UndirectedVertex objects.
+     * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
+     * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
+     * (`VertexId`).
+     * @returns an array of vertices (V[]).
      */
     UndirectedGraph.prototype.getNeighbors = function (vertexOrId) {
-        var e_2, _a;
+        var e_1, _a;
         var neighbors = [];
         var vertex = this._getVertex(vertexOrId);
         if (vertex) {
@@ -301,23 +266,22 @@ var UndirectedGraph = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
                     if (neighborEdges_1_1 && !neighborEdges_1_1.done && (_a = neighborEdges_1.return)) _a.call(neighborEdges_1);
                 }
-                finally { if (e_2) throw e_2.error; }
+                finally { if (e_1) throw e_1.error; }
             }
         }
         return neighbors;
     };
     /**
-     * The function "getEndsOfEdge" returns the two vertices that form the ends of a given undirected edge, or null if the
-     * edge does not exist in the graph.
-     * @param edge - An object representing an undirected edge in a graph. It has a property called "vertices" which is an
-     * array containing two vertices that the edge connects.
-     * @returns The function `getEndsOfEdge` returns an array containing the two ends of the given `edge` if the edge
-     * exists in the graph. If the edge does not exist, it returns `null`.
+     * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
+     * it returns null.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * graph. If the edge does not exist, it returns `null`.
      */
     UndirectedGraph.prototype.getEndsOfEdge = function (edge) {
         if (!this.hasEdge(edge.vertices[0], edge.vertices[1])) {
@@ -332,6 +296,43 @@ var UndirectedGraph = /** @class */ (function (_super) {
             return null;
         }
     };
+    /**
+     * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
+     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @returns a boolean value.
+     */
+    UndirectedGraph.prototype._addEdgeOnly = function (edge) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(edge.vertices), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var end = _c.value;
+                var endVertex = this._getVertex(end);
+                if (endVertex === null)
+                    return false;
+                if (endVertex) {
+                    var edges = this._edges.get(endVertex);
+                    if (edges) {
+                        edges.push(edge);
+                    }
+                    else {
+                        this._edges.set(endVertex, [edge]);
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return true;
+    };
+    /**
+     * The function sets the edges of a graph.
+     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     */
     UndirectedGraph.prototype._setEdges = function (v) {
         this._edges = v;
     };

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

@@ -1,28 +1,22 @@
 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;
+export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
     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 left(): NEIGHBOR | null | undefined;
+    set left(v: NEIGHBOR | null | undefined);
+    get right(): NEIGHBOR | null | undefined;
+    set right(v: NEIGHBOR | null | undefined);
+    get parent(): NEIGHBOR | null | undefined;
+    set parent(v: NEIGHBOR | 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;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
     get loopType(): LoopType;
     get visitedId(): BinaryTreeNodeId[];
     get visitedVal(): Array<N['val']>;
@@ -31,10 +25,10 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     get visitedLeftSum(): number[];
     get autoIncrementId(): boolean;
     get maxId(): number;
-    get isDuplicatedVal(): boolean;
+    get isMergeDuplicatedVal(): boolean;
     get root(): N | null;
     get size(): number;
-    get count(): number;
+    swapLocation(srcNode: N, destNode: N): N;
     clear(): void;
     isEmpty(): boolean;
     add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
@@ -45,7 +39,7 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     getDepth(node: N): number;
     getHeight(beginRoot?: N | null): number;
     getMinHeight(beginRoot?: N | null): number;
-    isBalanced(beginRoot?: N | null): boolean;
+    isPerfectlyBalanced(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;
@@ -58,7 +52,7 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     getRightMost(node?: N | null): N | null;
     isBSTByRooted(node: N | null): boolean;
     isBST(node?: N | null): boolean;
-    getSubTreeSizeAndCount(subTreeRoot: N | null | undefined): [number, number];
+    getSubTreeSize(subTreeRoot: N | null | undefined): number;
     subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
     subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     BFS(): BinaryTreeNodeId[];

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

@@ -1,8 +1,7 @@
 import { VertexId } from '../types';
 export interface IAbstractGraph<V, E> {
     hasVertex(vertexOrId: V | VertexId): boolean;
-    createAddVertex(id: VertexId, val?: V): boolean;
-    addVertex(newVertex: V): boolean;
+    addVertex(id: VertexId, val?: V): boolean;
     removeVertex(vertexOrId: V | VertexId): boolean;
     removeAllVertices(vertices: V[] | VertexId[]): boolean;
     degreeOf(vertexOrId: V | VertexId): number;
@@ -10,8 +9,7 @@ export interface IAbstractGraph<V, E> {
     hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
     getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
     edgeSet(): E[];
-    createAddEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
-    addEdge(edge: E): boolean;
+    addEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E): boolean;
     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,10 +1,10 @@
 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 IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
 }
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null): N | null | undefined;
     remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): BinaryTreeDeletedResult<N>[];
     balanceFactor(node: N): number;
     updateHeight(node: N): void;

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

@@ -1,6 +1,6 @@
 import { BinaryTreeNode } from '../binary-tree';
 import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
-export interface IBinaryTreeNode<T, FAMILY extends IBinaryTreeNode<T, FAMILY>> extends IAbstractBinaryTreeNode<T, FAMILY> {
+export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
 }
 export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
 }

package/dist/data-structures/interfaces/bst.d.ts

@@ -1,18 +1,17 @@
 import { BSTNode } from '../binary-tree';
 import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
 import { BinaryTreeDeletedResult, BinaryTreeNodeId, BinaryTreeNodePropertyName } from '../types';
-export interface IBSTNode<T, FAMILY extends IBSTNode<T, FAMILY>> extends IBinaryTreeNode<T, FAMILY> {
-    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
 }
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
-    createNode(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N;
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count: number): N | null;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null | undefined;
     get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     lastKey(): BinaryTreeNodeId;
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
     allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    balance(): boolean;
+    perfectlyBalance(): boolean;
     isAVLBalanced(): boolean;
 }

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

@@ -1,9 +1,8 @@
 import { RBTreeNode } from '../binary-tree';
 import { IBST, IBSTNode } from './bst';
 import { BinaryTreeNodeId } from '../types';
-export interface IRBTreeNode<T, FAMILY extends IRBTreeNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
-    createNode(id: BinaryTreeNodeId, val?: T | null, count?: number): FAMILY;
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
 }
 export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
-    createNode(id: BinaryTreeNodeId, val?: N | null, count?: number): N;
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
 }

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

@@ -1 +1,7 @@
-export {};
+import { TreeMultisetNode } from '../binary-tree';
+import { IBSTNode } from './bst';
+import { IAVLTree } from './avl-tree';
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+}

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

@@ -1,11 +1,8 @@
 export declare class TreeNode<T = number> {
-    constructor(id: string, name?: string, value?: T, children?: TreeNode<T>[]);
+    constructor(id: string, value?: T, children?: TreeNode<T>[]);
     private _id;
     get id(): string;
     set id(value: string);
-    private _name?;
-    get name(): string | undefined;
-    set name(value: string | undefined);
     private _value?;
     get value(): T | undefined;
     set value(value: T | undefined);

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

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNode = void 0;
 var TreeNode = /** @class */ (function () {
-    function TreeNode(id, name, value, children) {
+    function TreeNode(id, value, children) {
         this._id = id;
-        this._name = name || '';
         this._value = value || undefined;
         this._children = children || [];
     }
@@ -18,16 +17,6 @@ var TreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(TreeNode.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        set: function (value) {
-            this._name = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
     Object.defineProperty(TreeNode.prototype, "value", {
         get: function () {
             return this._value;

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

@@ -10,11 +10,15 @@ export declare enum LoopType {
     RECURSIVE = "RECURSIVE"
 }
 export declare enum FamilyPosition {
-    ROOT = 0,
-    LEFT = 1,
-    RIGHT = 2
+    ROOT = "ROOT",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    ROOT_LEFT = "ROOT_LEFT",
+    ROOT_RIGHT = "ROOT_RIGHT",
+    ISOLATED = "ISOLATED",
+    MAL_NODE = "MAL_NODE"
 }
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type BinaryTreeNodePropertyName = 'id' | 'val';
 export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
 export type DFSOrderPattern = 'in' | 'pre' | 'post';
 export type BinaryTreeNodeId = number;
@@ -24,9 +28,9 @@ export type BinaryTreeDeletedResult<N> = {
 };
 export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
 export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
-export type AbstractRecursiveBinaryTreeNode<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AbstractBinaryTreeOptions = {
     loopType?: LoopType;
     autoIncrementId?: boolean;
-    isDuplicatedVal?: boolean;
+    isMergeDuplicatedVal?: boolean;
 };

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

@@ -11,11 +11,15 @@ var LoopType;
 (function (LoopType) {
     LoopType["ITERATIVE"] = "ITERATIVE";
     LoopType["RECURSIVE"] = "RECURSIVE";
-})(LoopType || (exports.LoopType = LoopType = {}));
+})(LoopType = exports.LoopType || (exports.LoopType = {}));
 /* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 var FamilyPosition;
 (function (FamilyPosition) {
-    FamilyPosition[FamilyPosition["ROOT"] = 0] = "ROOT";
-    FamilyPosition[FamilyPosition["LEFT"] = 1] = "LEFT";
-    FamilyPosition[FamilyPosition["RIGHT"] = 2] = "RIGHT";
-})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));

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

@@ -1,4 +1,4 @@
 import { AVLTreeNode } from '../binary-tree';
 import { BSTOptions } from './bst';
-export type RecursiveAVLTreeNode<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AVLTreeOptions = BSTOptions & {};

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

@@ -1,4 +1,4 @@
 import { BinaryTreeNode } from '../binary-tree';
 import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
-export type RecursiveBinaryTreeNode<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions = AbstractBinaryTreeOptions & {};