data-structure-typed 1.18.5 → 1.18.6

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

@@ -5,14 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult, RecursiveBSTNode } from '../types';
-import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, RecursiveBSTNode } from '../types';
+import { BinaryTreeDeletedResult, BSTOptions, CP } from '../types';
+import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
-export declare enum CP {
-    lt = -1,
-    eq = 0,
-    gt = 1
-}
 export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BinaryTree<N> implements IBinaryTree<N> {
@@ -20,10 +16,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * The constructor function accepts an optional options object and sets the comparator property if provided.
      * @param [options] - An optional object that can contain the following properties:
      */
-    constructor(options?: {
-        comparator?: BSTComparator;
-        loopType?: LoopType;
-    });
+    constructor(options?: BSTOptions);
     _createNode(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
@@ -67,7 +60,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * set to false or not provided, the count of the node will be taken into account and the
      * @returns an array of `BSTDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<N>[];
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
      * option to specify the property name and whether to return only one node.

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

@@ -31,14 +31,9 @@ var __read = (this && this.__read) || function (o, n) {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BST = exports.BSTNode = exports.CP = void 0;
+exports.BST = exports.BSTNode = void 0;
+var types_1 = require("../types");
 var binary_tree_1 = require("./binary-tree");
-var CP;
-(function (CP) {
-    CP[CP["lt"] = -1] = "lt";
-    CP[CP["eq"] = 0] = "eq";
-    CP[CP["gt"] = 1] = "gt";
-})(CP || (exports.CP = CP = {}));
 var BSTNode = /** @class */ (function (_super) {
     __extends(BSTNode, _super);
     function BSTNode() {
@@ -95,7 +90,7 @@ var BST = /** @class */ (function (_super) {
             var traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, id) === CP.eq) {
+                    if (this._compare(cur.id, id) === types_1.CP.eq) {
                         if (newNode) {
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
@@ -105,12 +100,12 @@ var BST = /** @class */ (function (_super) {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, id) === CP.gt) {
+                    else if (this._compare(cur.id, id) === types_1.CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = binary_tree_1.FamilyPosition.left;
+                                newNode.familyPosition = types_1.FamilyPosition.LEFT;
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
@@ -125,12 +120,12 @@ var BST = /** @class */ (function (_super) {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, id) === CP.lt) {
+                    else if (this._compare(cur.id, id) === types_1.CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = binary_tree_1.FamilyPosition.right;
+                                newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
@@ -177,9 +172,9 @@ var BST = /** @class */ (function (_super) {
      */
     BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
-        if (this._compare(0, 1) === CP.lt)
+        if (this._compare(0, 1) === types_1.CP.lt)
             return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
-        else if (this._compare(0, 1) === CP.gt)
+        else if (this._compare(0, 1) === types_1.CP.gt)
             return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
@@ -215,10 +210,10 @@ var BST = /** @class */ (function (_super) {
                 }
                 else {
                     switch (curr.familyPosition) {
-                        case binary_tree_1.FamilyPosition.left:
+                        case types_1.FamilyPosition.LEFT:
                             parent.left = curr.right;
                             break;
-                        case binary_tree_1.FamilyPosition.right:
+                        case types_1.FamilyPosition.RIGHT:
                             parent.right = curr.right;
                             break;
                     }
@@ -264,16 +259,16 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return [];
         var result = [];
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_1 = function (cur) {
                 if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
                 if (propertyName === 'id') {
-                    if (_this._compare(cur.id, nodeProperty) === CP.gt)
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.gt)
                         cur.left && _traverse_1(cur.left);
-                    if (_this._compare(cur.id, nodeProperty) === CP.lt)
+                    if (_this._compare(cur.id, nodeProperty) === types_1.CP.lt)
                         cur.right && _traverse_1(cur.right);
                 }
                 else {
@@ -291,9 +286,9 @@ var BST = /** @class */ (function (_super) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
                     if (propertyName === 'id') {
-                        if (this._compare(cur.id, nodeProperty) === CP.gt)
+                        if (this._compare(cur.id, nodeProperty) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.id, nodeProperty) === CP.lt)
+                        if (this._compare(cur.id, nodeProperty) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -337,15 +332,15 @@ var BST = /** @class */ (function (_super) {
             return needSum;
         };
         var sum = 0;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_2 = function (cur) {
                 var compared = _this._compare(cur.id, id);
-                if (compared === CP.eq) {
+                if (compared === types_1.CP.eq) {
                     if (cur.right)
                         sum += _this.subTreeSum(cur.right, propertyName);
                     return;
                 }
-                else if (compared === CP.lt) {
+                else if (compared === types_1.CP.lt) {
                     if (cur.left)
                         sum += _this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
@@ -369,12 +364,12 @@ var BST = /** @class */ (function (_super) {
                 var cur = queue.shift();
                 if (cur) {
                     var compared = this._compare(cur.id, id);
-                    if (compared === CP.eq) {
+                    if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
                         return sum;
                     }
-                    else if (compared === CP.lt) { // todo maybe a bug
+                    else if (compared === types_1.CP.lt) { // todo maybe a bug
                         if (cur.left)
                             sum += this.subTreeSum(cur.left, propertyName);
                         sum += getSumByPropertyName(cur);
@@ -424,15 +419,15 @@ var BST = /** @class */ (function (_super) {
                     break;
             }
         };
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_3 = function (cur) {
                 var compared = _this._compare(cur.id, node.id);
                 _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && compared === CP.gt)
+                if (cur.left && compared === types_1.CP.gt)
                     _traverse_3(cur.left);
-                else if (cur.right && compared === CP.gt)
+                else if (cur.right && compared === types_1.CP.gt)
                     _traverse_3(cur.right);
             };
             _traverse_3(this.root);
@@ -445,9 +440,9 @@ var BST = /** @class */ (function (_super) {
                 if (cur) {
                     var compared = this._compare(cur.id, node.id);
                     _sumByPropertyName(cur);
-                    if (cur.left && compared === CP.gt)
+                    if (cur.left && compared === types_1.CP.gt)
                         queue.push(cur.left);
-                    else if (cur.right && compared === CP.gt)
+                    else if (cur.right && compared === types_1.CP.gt)
                         queue.push(cur.right);
                 }
             }
@@ -465,7 +460,7 @@ var BST = /** @class */ (function (_super) {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
@@ -506,7 +501,7 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return true;
         var balanced = true;
-        if (this.loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _height_1 = function (cur) {
                 if (!cur)
                     return 0;
@@ -558,11 +553,11 @@ var BST = /** @class */ (function (_super) {
     BST.prototype._compare = function (a, b) {
         var compared = this._comparator(a, b);
         if (compared > 0)
-            return CP.gt;
+            return types_1.CP.gt;
         else if (compared < 0)
-            return CP.lt;
+            return types_1.CP.lt;
         else
-            return CP.eq;
+            return types_1.CP.eq;
     };
     return BST;
 }(binary_tree_1.BinaryTree));

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

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

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

@@ -14,6 +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("./abstract-binary-tree"), exports);
 __exportStar(require("./binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./binary-indexed-tree"), exports);

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

@@ -16,11 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 var binary_tree_1 = require("./binary-tree");
-var RBColor;
-(function (RBColor) {
-    RBColor[RBColor["Red"] = 0] = "Red";
-    RBColor[RBColor["Black"] = 1] = "Black";
-})(RBColor || (RBColor = {}));
+var types_1 = require("../types");
 var RBNode = /** @class */ (function (_super) {
     __extends(RBNode, _super);
     // override createNode(id: BinaryTreeNodeId, val: T | null, count?: number): RBNode<T> | null {
@@ -28,7 +24,7 @@ var RBNode = /** @class */ (function (_super) {
     // }
     function RBNode(id, val, count) {
         var _this = _super.call(this, id, val, count) || this;
-        _this._color = RBColor.Red;
+        _this._color = types_1.RBColor.RED;
         return _this;
     }
     Object.defineProperty(RBNode.prototype, "color", {

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

@@ -6,9 +6,15 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
-import { IBinaryTree } from '../interfaces';
+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> {
+}
+/**
+ * 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> {
+    constructor(options?: TreeMultiSetOptions);
     /**
      * The function creates a new BSTNode with the given id, value, and count.
      * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
@@ -19,25 +25,4 @@ export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<numbe
      * @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;
-    /**
-     * The function overrides the add method of the BinarySearchTree class in TypeScript.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `N` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
-     */
-    add(id: BinaryTreeNodeId, val: N | null, count?: number): N | null;
-    /**
-     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
-     * method.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
-     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
-     * set to `true`, the left sum of all nodes will be recalculated. If it
-     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
-     */
-    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<N>[];
 }

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

@@ -14,8 +14,19 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultiSet = void 0;
+exports.TreeMultiSet = exports.TreeMultiSetNode = void 0;
 /**
  * data-structure-typed
  *
@@ -24,10 +35,21 @@ exports.TreeMultiSet = void 0;
  * @license MIT License
  */
 var bst_1 = require("./bst");
+var TreeMultiSetNode = /** @class */ (function (_super) {
+    __extends(TreeMultiSetNode, _super);
+    function TreeMultiSetNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return TreeMultiSetNode;
+}(bst_1.BSTNode));
+exports.TreeMultiSetNode = TreeMultiSetNode;
+/**
+ * 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.
+ */
 var TreeMultiSet = /** @class */ (function (_super) {
     __extends(TreeMultiSet, _super);
-    function TreeMultiSet() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function TreeMultiSet(options) {
+        return _super.call(this, __assign(__assign({}, options), { isDuplicatedVal: true })) || this;
     }
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -39,34 +61,9 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * @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 bst_1.BSTNode(id, val, count);
+        var node = new TreeMultiSetNode(id, val, count);
         return node;
     };
-    /**
-     * The function overrides the add method of the BinarySearchTree class in TypeScript.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
-     * @param {N | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `N` (the generic type) or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
-     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
-     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
-     */
-    TreeMultiSet.prototype.add = function (id, val, count) {
-        return _super.prototype.add.call(this, id, val, count);
-    };
-    /**
-     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
-     * method.
-     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
-     * removed from the tree.
-     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
-     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
-     * set to `true`, the left sum of all nodes will be recalculated. If it
-     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
-     */
-    TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
-        return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
-    };
     return TreeMultiSet;
 }(bst_1.BST));
 exports.TreeMultiSet = TreeMultiSet;

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

@@ -32,10 +32,8 @@ export declare class DirectedEdge<T = number> extends AbstractEdge<T> {
     get dest(): VertexId;
     set dest(v: VertexId);
 }
-export declare class DirectedGraph<V extends DirectedVertex<any>, E extends DirectedEdge<any>> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
-    private readonly _vertexConstructor;
-    private readonly _edgeConstructor;
-    constructor(vertexConstructor: new (id: VertexId, val?: V['val']) => V, edgeConstructor: new (src: VertexId, dest: VertexId, weight?: number, val?: E['val']) => E);
+export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
+    constructor();
     private _outEdgeMap;
     get outEdgeMap(): Map<V, E[]>;
     private _inEdgeMap;

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

@@ -122,12 +122,10 @@ exports.DirectedEdge = DirectedEdge;
 // Strongly connected, One direction connected, Weakly connected
 var DirectedGraph = /** @class */ (function (_super) {
     __extends(DirectedGraph, _super);
-    function DirectedGraph(vertexConstructor, edgeConstructor) {
+    function DirectedGraph() {
         var _this = _super.call(this) || this;
         _this._outEdgeMap = new Map();
         _this._inEdgeMap = new Map();
-        _this._vertexConstructor = vertexConstructor;
-        _this._edgeConstructor = edgeConstructor;
         return _this;
     }
     Object.defineProperty(DirectedGraph.prototype, "outEdgeMap", {
@@ -151,7 +149,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param val
      */
     DirectedGraph.prototype._createVertex = function (id, val) {
-        return new this._vertexConstructor(id, val);
+        return new DirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
@@ -162,9 +160,7 @@ var DirectedGraph = /** @class */ (function (_super) {
      * @param val
      */
     DirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
-        if (weight === undefined || weight === null)
-            weight = 1;
-        return new this._edgeConstructor(src, dest, weight, val);
+        return new DirectedEdge(src, dest, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
      * The function `getEdge` returns the directed edge between two vertices, given their source and destination.

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

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

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

@@ -108,10 +108,8 @@ var UndirectedEdge = /** @class */ (function (_super) {
 exports.UndirectedEdge = UndirectedEdge;
 var UndirectedGraph = /** @class */ (function (_super) {
     __extends(UndirectedGraph, _super);
-    function UndirectedGraph(vertexConstructor, edgeConstructor) {
+    function UndirectedGraph() {
         var _this = _super.call(this) || this;
-        _this._vertexConstructor = vertexConstructor;
-        _this._edgeConstructor = edgeConstructor;
         _this._edges = new Map();
         return _this;
     }
@@ -129,20 +127,22 @@ var UndirectedGraph = /** @class */ (function (_super) {
      * @param val
      */
     UndirectedGraph.prototype._createVertex = function (id, val) {
-        return new this._vertexConstructor(id, val);
+        return new UndirectedVertex(id, val !== null && val !== void 0 ? val : id);
     };
     /**
-     * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
-     * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
-     * @param src
-     * @param dest
-     * @param weight
-     * @param val
+     * The function _createEdge creates an undirected edge between two vertices with an optional weight and value.
+     * @param {VertexId} v1 - The parameter `v1` represents the first vertex of the edge. It is of type `VertexId`, which
+     * could be a unique identifier or label for the vertex.
+     * @param {VertexId} v2 - The parameter `v2` represents the second vertex of the edge. It is of type `VertexId`, which
+     * is typically a unique identifier for a vertex in a graph.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge. If no
+     * weight is provided, the default value is 1.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
+     * is used to store additional information or data associated with the edge.
+     * @returns an instance of the UndirectedEdge class, casted as type E.
      */
-    UndirectedGraph.prototype._createEdge = function (src, dest, weight, val) {
-        if (weight === undefined || weight === null)
-            weight = 1;
-        return new this._edgeConstructor(src, dest, weight, val);
+    UndirectedGraph.prototype._createEdge = function (v1, v2, weight, val) {
+        return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
     };
     /**
      * The function `getEdge` returns the first undirected edge that connects two given vertices, or null if no such edge

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

@@ -1,5 +1,4 @@
-import { BinaryTreeNodeId } from '../types';
-import { FamilyPosition } from '../binary-tree';
+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;

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

@@ -0,0 +1,32 @@
+import { AbstractBinaryTreeNode } from '../binary-tree';
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+export declare enum LoopType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare enum FamilyPosition {
+    ROOT = 0,
+    LEFT = 1,
+    RIGHT = 2
+}
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+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 AbstractBinaryTreeOptions = {
+    loopType?: LoopType;
+    autoIncrementId?: boolean;
+    isDuplicatedVal?: boolean;
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyPosition = exports.LoopType = void 0;
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
+var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType || (exports.LoopType = 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 = {}));

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

@@ -1,6 +1,4 @@
 import { AVLTreeNode } from '../binary-tree';
-export type AVLTreeDeleted<N> = {
-    deleted: N | null;
-    needBalanced: N | null;
-};
+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 AVLTreeOptions = BSTOptions & {};