data-structure-typed 1.18.6 → 1.18.8

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.
@@ -60,13 +61,6 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @returns an instance of `E` or `null`.
      */
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | 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.
-     */
-    addEdge(edge: E): boolean;
     /**
      * 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
@@ -105,13 +99,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
@@ -128,5 +115,12 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * exists in the graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge: E): [V, V] | 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.
+     */
+    protected _addEdgeOnly(edge: E): boolean;
     protected _setEdges(v: Map<V, E[]>): void;
 }

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;
 /**
@@ -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);
     };
     /**
@@ -165,40 +165,6 @@ 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
@@ -280,19 +246,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
@@ -300,11 +253,11 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * @returns an array of UndirectedVertex objects.
      */
     UndirectedGraph.prototype.getNeighbors = function (vertexOrId) {
-        var e_2, _a;
+        var e_1, _a;
         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;
@@ -314,12 +267,12 @@ 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;
@@ -345,6 +298,40 @@ var UndirectedGraph = /** @class */ (function (_super) {
             return 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._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;
+    };
     UndirectedGraph.prototype._setEdges = function (v) {
         this._edges = v;
     };

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

@@ -0,0 +1,100 @@
+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;
+    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'], 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 isMergeDuplicatedVal(): 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,10 +1,7 @@
 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;
+    addVertex(id: VertexId, val?: V): boolean;
     removeVertex(vertexOrId: V | VertexId): boolean;
     removeAllVertices(vertices: V[] | VertexId[]): boolean;
     degreeOf(vertexOrId: V | VertexId): number;
@@ -12,9 +9,7 @@ export interface IGraph<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;
-    removeEdgeBetween(src: V | VertexId, dest: V | VertexId): E | null;
+    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 +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;
+}

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

@@ -1,26 +1,6 @@
-import { BinaryTreeNodeId, FamilyPosition } from '../types';
-export interface IBinaryTreeNode<T, FAMILY extends IBinaryTreeNode<T, FAMILY>> {
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
-    get id(): BinaryTreeNodeId;
-    set id(v: BinaryTreeNodeId);
-    get val(): T;
-    set val(v: T);
-    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);
-    _createNode(id: BinaryTreeNodeId, val: T | null, count?: number): FAMILY | null;
-    swapLocation(swapNode: FAMILY): FAMILY;
-    clone(): FAMILY | null;
+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 IBinaryTree<N extends IBinaryTreeNode<N['val'], N>> {
-    _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
 }

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

@@ -1 +1,18 @@
-export {};
+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 IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    add(id: BinaryTreeNodeId, val?: N['val'] | null, count?: number): N | null;
+    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;
+    isAVLBalanced(): boolean;
+}

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

@@ -1,9 +1,12 @@
 import { VertexId } from '../types';
-export interface IDirectedGraph<V, E> {
+import { IAbstractGraph } from './abstract-graph';
+export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
     incomingEdgesOf(vertex: V): E[];
     outgoingEdgesOf(vertex: V): E[];
     inDegreeOf(vertexOrId: V | VertexId): number;
     outDegreeOf(vertexOrId: V | VertexId): number;
     getEdgeSrc(e: E): V | null;
     getEdgeDest(e: E): V | null;
+    removeEdgeSrcToDest(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
+    removeEdgesBetween(v1: V | VertexId, v2: V | VertexId): E[];
 }

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

@@ -1,4 +1,4 @@
-export * from './binary-tree';
+export * from './abstract-binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';

package/dist/data-structures/interfaces/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./abstract-binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);

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

@@ -0,0 +1,9 @@
+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, count?: number): FAMILY;
+}
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+}

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

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

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, FAMILY extends ITreeMultiSetNode<T, FAMILY>> extends IBSTNode<T, FAMILY> {
+}
+export interface ITreeMultiSet<N extends TreeMultiSetNode<N['val'], N>> extends IAVLTree<N> {
+}

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

@@ -1,2 +1,5 @@
-export interface IUNDirectedGraph<V, E> {
+import { VertexId } from '../types';
+import { IAbstractGraph } from './abstract-graph';
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+    removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;
 }

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,9 +10,13 @@ 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 NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
@@ -22,11 +26,11 @@ export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null;
 };
-export type AbstractResultByProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
-export type AbstractResultsByProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractResultByProperty<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 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 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 & {};