data-structure-typed 1.17.4 → 1.18.5

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

@@ -5,17 +5,17 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult } from '../types';
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult, RecursiveBSTNode } from '../types';
 import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
+import { IBinaryTree, IBinaryTreeNode } from '../interfaces';
 export declare enum CP {
     lt = -1,
     eq = 0,
     gt = 1
 }
-export declare class BSTNode<T> extends BinaryTreeNode<T> {
-    clone(): BSTNode<T>;
+export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBinaryTreeNode<T, FAMILY> {
 }
-export declare class BST<T> extends BinaryTree<T> {
+export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BinaryTree<N> implements IBinaryTree<N> {
     /**
      * 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:
@@ -24,30 +24,30 @@ export declare class BST<T> extends BinaryTree<T> {
         comparator?: BSTComparator;
         loopType?: LoopType;
     });
-    createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    _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
      * the ID matches, and returns the inserted node.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
      * determine the position of the node in the binary search tree.
-     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
-     * be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `N` (the generic type) or `null`.
      * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
      * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
      * inserted once.
-     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
+     * @returns The method `add` returns a `N` object or `null`.
      */
-    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
     /**
      * The `get` function returns the first node in a binary search tree that matches the given property value or name.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the value of the property that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
      * `'id'`.
-     * @returns The method is returning a BSTNode<T> object or null.
+     * @returns The method is returning a N object or null.
      */
-    get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
+    get(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName): N | null;
     /**
      * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
      * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
@@ -65,23 +65,23 @@ export declare class BST<T> extends BinaryTree<T> {
      * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
      * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
      * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<T>` objects.
+     * @returns an array of `BSTDeletedResult<N>` objects.
      */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[];
+    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<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.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property value that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
      * `'id'`.
      * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
      * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
      * to false or not provided, the function will return all nodes that match the given nodeProperty.
-     * @returns an array of BSTNode<T> objects.
+     * @returns an array of N objects.
      */
-    getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): BSTNode<T>[];
+    getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
      * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
      * a binary search tree.
@@ -96,7 +96,7 @@ export declare class BST<T> extends BinaryTree<T> {
     /**
      * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
      * that have a greater value than a given node.
-     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * @param node - The `node` parameter is of type `N`, which represents a node in a binary search tree. It
      * contains properties such as `id` and `count`.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each node should be increased.
@@ -105,7 +105,7 @@ export declare class BST<T> extends BinaryTree<T> {
      * defaults to 'id'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
      * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
      * recursive or iterative approach.

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

@@ -38,15 +38,12 @@ var CP;
     CP[CP["lt"] = -1] = "lt";
     CP[CP["eq"] = 0] = "eq";
     CP[CP["gt"] = 1] = "gt";
-})(CP = exports.CP || (exports.CP = {}));
+})(CP || (exports.CP = CP = {}));
 var BSTNode = /** @class */ (function (_super) {
     __extends(BSTNode, _super);
     function BSTNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    BSTNode.prototype.clone = function () {
-        return new BSTNode(this.id, this.val, this.count);
-    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
@@ -67,30 +64,30 @@ var BST = /** @class */ (function (_super) {
         }
         return _this;
     }
-    BST.prototype.createNode = function (id, val, count) {
-        return val !== null ? new BSTNode(id, val, count) : null;
+    BST.prototype._createNode = function (id, val, count) {
+        var node = val !== null ? new BSTNode(id, val, count) : null;
+        return node;
     };
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
      * the ID matches, and returns the inserted node.
      * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
      * determine the position of the node in the binary search tree.
-     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
-     * be of type `T` (the generic type) or `null`.
+     * @param {N | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `N` (the generic type) or `null`.
      * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
      * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
      * inserted once.
-     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
+     * @returns The method `add` returns a `N` object or `null`.
      */
     BST.prototype.add = function (id, val, count) {
-        var _a;
         if (count === void 0) { count = 1; }
         var inserted = null;
-        var newNode = this.createNode(id, val, count);
+        var newNode = this._createNode(id, val, count);
         if (this.root === null) {
-            this.root = newNode;
-            this.size++;
-            this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 1;
+            this._setRoot(newNode);
+            this._setSize(this.size + 1);
+            this._setCount(this.count + count);
             inserted = (this.root);
         }
         else {
@@ -101,7 +98,7 @@ var BST = /** @class */ (function (_super) {
                     if (this._compare(cur.id, id) === CP.eq) {
                         if (newNode) {
                             cur.count += newNode.count;
-                            this.count += newNode.count;
+                            this._setCount(this.count + newNode.count);
                             cur.val = newNode.val;
                         }
                         //Duplicates are not accepted.
@@ -117,8 +114,8 @@ var BST = /** @class */ (function (_super) {
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
-                            this.size++;
-                            this.count += newNode.count;
+                            this._setSize(this.size + 1);
+                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -137,8 +134,8 @@ var BST = /** @class */ (function (_super) {
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
-                            this.size++;
-                            this.count += newNode.count;
+                            this._setSize(this.size + 1);
+                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = (cur.right);
                         }
@@ -158,12 +155,12 @@ var BST = /** @class */ (function (_super) {
     };
     /**
      * The `get` function returns the first node in a binary search tree that matches the given property value or name.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the value of the property that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
      * `'id'`.
-     * @returns The method is returning a BSTNode<T> object or null.
+     * @returns The method is returning a N object or null.
      */
     BST.prototype.get = function (nodeProperty, propertyName) {
         var _a;
@@ -195,7 +192,7 @@ var BST = /** @class */ (function (_super) {
      * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
      * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
      * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<T>` objects.
+     * @returns an array of `BSTDeletedResult<N>` objects.
      */
     BST.prototype.remove = function (id, ignoreCount) {
         var bstDeletedResult = [];
@@ -208,13 +205,13 @@ var BST = /** @class */ (function (_super) {
         var needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
-            this.count--;
+            this._setCount(this.count - 1);
         }
         else {
             if (!curr.left) {
                 if (!parent) {
                     if (curr.right !== undefined)
-                        this.root = curr.right;
+                        this._setRoot(curr.right);
                 }
                 else {
                     switch (curr.familyPosition) {
@@ -242,8 +239,8 @@ var BST = /** @class */ (function (_super) {
                     }
                 }
             }
-            this.size--;
-            this.count -= curr.count;
+            this._setSize(this.size - 1);
+            this._setCount(this.count - curr.count);
         }
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
         return bstDeletedResult;
@@ -251,15 +248,15 @@ var BST = /** @class */ (function (_super) {
     /**
      * 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.
-     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
-     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `N`. It represents the property value that you want to search for in the binary search tree.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
      * `'id'`.
      * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
      * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
      * to false or not provided, the function will return all nodes that match the given nodeProperty.
-     * @returns an array of BSTNode<T> objects.
+     * @returns an array of N objects.
      */
     BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -267,7 +264,7 @@ var BST = /** @class */ (function (_super) {
         if (!this.root)
             return [];
         var result = [];
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_1 = function (cur) {
                 if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
@@ -340,7 +337,7 @@ var BST = /** @class */ (function (_super) {
             return needSum;
         };
         var sum = 0;
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_2 = function (cur) {
                 var compared = _this._compare(cur.id, id);
                 if (compared === CP.eq) {
@@ -400,7 +397,7 @@ var BST = /** @class */ (function (_super) {
     /**
      * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
      * that have a greater value than a given node.
-     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * @param node - The `node` parameter is of type `N`, which represents a node in a binary search tree. It
      * contains properties such as `id` and `count`.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each node should be increased.
@@ -427,7 +424,7 @@ var BST = /** @class */ (function (_super) {
                     break;
             }
         };
-        if (this._loopType === binary_tree_1.LoopType.recursive) {
+        if (this.loopType === binary_tree_1.LoopType.recursive) {
             var _traverse_3 = function (cur) {
                 var compared = _this._compare(cur.id, node.id);
                 _sumByPropertyName(cur);
@@ -468,7 +465,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 === binary_tree_1.LoopType.recursive) {
             var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
@@ -509,7 +506,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 === binary_tree_1.LoopType.recursive) {
             var _height_1 = function (cur) {
                 if (!cur)
                     return 0;

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

@@ -1,2 +1 @@
-export declare class RBTree {
-}
+export {};

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

@@ -1,9 +1,72 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTree = void 0;
-var RBTree = /** @class */ (function () {
-    function RBTree() {
+var binary_tree_1 = require("./binary-tree");
+var RBColor;
+(function (RBColor) {
+    RBColor[RBColor["Red"] = 0] = "Red";
+    RBColor[RBColor["Black"] = 1] = "Black";
+})(RBColor || (RBColor = {}));
+var RBNode = /** @class */ (function (_super) {
+    __extends(RBNode, _super);
+    // override createNode(id: BinaryTreeNodeId, val: T | null, count?: number): RBNode<T> | null {
+    //     return val !== null ? new RBNode<T>(id, val, count) : null;
+    // }
+    function RBNode(id, val, count) {
+        var _this = _super.call(this, id, val, count) || this;
+        _this._color = RBColor.Red;
+        return _this;
     }
+    Object.defineProperty(RBNode.prototype, "color", {
+        get: function () {
+            return this._color;
+        },
+        set: function (value) {
+            this._color = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RBNode;
+}(binary_tree_1.BinaryTreeNode));
+var RBTree = /** @class */ (function (_super) {
+    __extends(RBTree, _super);
+    function RBTree(options) {
+        return _super.call(this, options) || this;
+    }
+    // override _createNode(id: BinaryTreeNodeId, val: N | null, count?: number): RBNode<N> | null {
+    //     return val !== null ? new RBNode<N>(id, val, count) : null;
+    // }
+    // private override _root: BinaryTreeNode<N> | null = null;
+    //
+    // override get root(): BinaryTreeNode<N> | null {
+    //     return this._root;
+    // }
+    RBTree.prototype.insert = function (id, val) {
+    };
+    RBTree.prototype.leftRotate = function (node) {
+    };
+    RBTree.prototype.rightRotate = function (node) {
+    };
+    RBTree.prototype.insertFixup = function (node) {
+    };
+    RBTree.prototype.deleteFixup = function (node) {
+    };
+    RBTree.prototype.transplant = function (u, v) {
+    };
     return RBTree;
-}());
-exports.RBTree = RBTree;
+}(binary_tree_1.BinaryTree));

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

@@ -8,53 +8,26 @@
 import type { SegmentTreeNodeVal } from '../types';
 export declare class SegmentTreeNode {
     constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
-    protected _start: number;
+    private _start;
     get start(): number;
     set start(v: number);
-    protected _end: number;
+    private _end;
     get end(): number;
     set end(v: number);
-    protected _val: SegmentTreeNodeVal | null;
+    private _val;
     get val(): SegmentTreeNodeVal | null;
     set val(v: SegmentTreeNodeVal | null);
-    protected _sum: number;
+    private _sum;
     get sum(): number;
     set sum(v: number);
-    protected _left: SegmentTreeNode | null;
+    private _left;
     get left(): SegmentTreeNode | null;
     set left(v: SegmentTreeNode | null);
-    protected _right: SegmentTreeNode | null;
+    private _right;
     get right(): SegmentTreeNode | null;
     set right(v: SegmentTreeNode | null);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getStart(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getEnd(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getVal(): SegmentTreeNodeVal | null;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getSum(): number;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getLeft(): SegmentTreeNode | null;
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRight(): SegmentTreeNode | null;
 }
 export declare class SegmentTree {
-    protected _values: number[];
-    protected _start: number;
-    protected _end: number;
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -65,13 +38,14 @@ export declare class SegmentTree {
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
     constructor(values: number[], start?: number, end?: number);
-    protected _root: SegmentTreeNode | null;
+    private _values;
+    get values(): number[];
+    private _start;
+    get start(): number;
+    private _end;
+    get end(): number;
+    private _root;
     get root(): SegmentTreeNode | null;
-    set root(v: SegmentTreeNode | null);
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    getRoot(): SegmentTreeNode | null;
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.
@@ -102,4 +76,8 @@ export declare class SegmentTree {
      * @returns The function `querySumByRange` returns a number.
      */
     querySumByRange(indexA: number, indexB: number): number;
+    protected _setValues(value: number[]): void;
+    protected _setStart(value: number): void;
+    protected _setEnd(value: number): void;
+    protected _setRoot(v: SegmentTreeNode | null): void;
 }

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

@@ -81,42 +81,6 @@ var SegmentTreeNode = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getStart = function () {
-        return this._start;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getEnd = function () {
-        return this._end;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getVal = function () {
-        return this._val;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getSum = function () {
-        return this._sum;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getLeft = function () {
-        return this._left;
-    };
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTreeNode.prototype.getRight = function () {
-        return this._right;
-    };
     return SegmentTreeNode;
 }());
 exports.SegmentTreeNode = SegmentTreeNode;
@@ -140,22 +104,34 @@ var SegmentTree = /** @class */ (function () {
         this._end = end;
         this._root = this.build(start, end);
     }
+    Object.defineProperty(SegmentTree.prototype, "values", {
+        get: function () {
+            return this._values;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTree.prototype, "start", {
+        get: function () {
+            return this._start;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SegmentTree.prototype, "end", {
+        get: function () {
+            return this._end;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(SegmentTree.prototype, "root", {
         get: function () {
             return this._root;
         },
-        set: function (v) {
-            this._root = v;
-        },
         enumerable: false,
         configurable: true
     });
-    /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
-     */
-    SegmentTree.prototype.getRoot = function () {
-        return this._root;
-    };
     /**
      * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
      * for each segment.
@@ -166,9 +142,8 @@ var SegmentTree = /** @class */ (function () {
      * @returns a SegmentTreeNode object.
      */
     SegmentTree.prototype.build = function (start, end) {
-        if (start === end) {
+        if (start === end)
             return new SegmentTreeNode(start, end, this._values[start]);
-        }
         var mid = start + Math.floor((end - start) / 2);
         var left = this.build(start, mid);
         var right = this.build(mid + 1, end);
@@ -264,6 +239,18 @@ var SegmentTree = /** @class */ (function () {
         };
         return dfs(root, indexA, indexB);
     };
+    SegmentTree.prototype._setValues = function (value) {
+        this._values = value;
+    };
+    SegmentTree.prototype._setStart = function (value) {
+        this._start = value;
+    };
+    SegmentTree.prototype._setEnd = function (value) {
+        this._end = value;
+    };
+    SegmentTree.prototype._setRoot = function (v) {
+        this._root = v;
+    };
     return SegmentTree;
 }());
 exports.SegmentTree = SegmentTree;

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

@@ -7,27 +7,28 @@
  */
 import { BST, BSTNode } from './bst';
 import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
-export declare class TreeMultiSet<T> extends BST<T> {
+import { IBinaryTree } from '../interfaces';
+export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBinaryTree<N> {
     /**
      * 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
      * distinguish one node from another in the tree.
-     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
-    createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
+    _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 {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
-     * can be of type `T` (the generic type) or `null`.
+     * @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<T>` object or `null`.
+     * @returns The `add` method is returning a `BSTNode<N>` object or `null`.
      */
-    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | 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.
@@ -38,5 +39,5 @@ export declare class TreeMultiSet<T> extends BST<T> {
      * 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<T>[];
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<N>[];
 }