data-structure-typed 1.18.8 → 1.19.0

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

@@ -39,27 +39,14 @@ var BSTNode = /** @class */ (function (_super) {
     function BSTNode() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    /**
-     * The function creates a new binary search tree node with the specified id, value, and count.
-     * @param {BinaryTreeNodeId} id - The id parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param {T} [val] - The "val" parameter represents the value that will be stored in the binary tree node. It is an
-     * optional parameter, meaning it can be omitted when calling the "createNode" function.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary
-     * search tree node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
-     * @returns The method is returning a new instance of the BSTNode class, casted as the FAMILY type.
-     */
-    BSTNode.prototype.createNode = function (id, val, count) {
-        return new BSTNode(id, val, count);
-    };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
 var BST = /** @class */ (function (_super) {
     __extends(BST, _super);
     /**
-     * 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:
+     * The constructor function initializes a binary search tree object with an optional comparator function.
+     * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.
      */
     function BST(options) {
         var _this = _super.call(this, options) || this;
@@ -73,38 +60,31 @@ var BST = /** @class */ (function (_super) {
         return _this;
     }
     /**
-     * The function creates a new binary search tree node with the given id, value, and count.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is of type
-     * `BinaryTreeNodeId`.
-     * @param {N['val'] | null} [val] - The `val` parameter is the value that will be stored in the node. It can be of any
-     * type `N['val']` or `null`.
-     * @param {number} [count] - The `count` parameter is an optional parameter that represents the number of occurrences
-     * of a particular value in the binary search tree node.
-     * @returns a new instance of the BSTNode class, casted as type N.
+     * The function creates a new binary search tree node with the given id and value.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * identify each node in the binary tree.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
+     * that will be stored in the node.
+     * @returns a new instance of the BSTNode class with the specified id and value.
      */
-    BST.prototype.createNode = function (id, val, count) {
-        return new BSTNode(id, val, count);
+    BST.prototype.createNode = function (id, val) {
+        return new BSTNode(id, val);
     };
     /**
-     * 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 {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 `N` object or `null`.
+     * The `add` function adds a new node to a binary tree, ensuring that duplicates are not accepted.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add. It
+     * is of type `BinaryTreeNodeId`.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. It represents
+     * the value associated with the node.
+     * @returns The function `add` returns the inserted node (`inserted`) if it was successfully added to the binary tree.
+     * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
-    BST.prototype.add = function (id, val, count) {
-        if (count === void 0) { count = 1; }
+    BST.prototype.add = function (id, val) {
         var inserted = null;
-        var newNode = this.createNode(id, val, count);
+        var newNode = this.createNode(id, val);
         if (this.root === null) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
-            this._setCount(this.count + count);
             inserted = (this.root);
         }
         else {
@@ -114,8 +94,6 @@ var BST = /** @class */ (function (_super) {
                 if (cur !== null && newNode !== null) {
                     if (this._compare(cur.id, id) === types_1.CP.eq) {
                         if (newNode) {
-                            cur.count += newNode.count;
-                            this._setCount(this.count + newNode.count);
                             cur.val = newNode.val;
                         }
                         //Duplicates are not accepted.
@@ -131,7 +109,6 @@ var BST = /** @class */ (function (_super) {
                             //Add to the left of the current node
                             cur.left = newNode;
                             this._setSize(this.size + 1);
-                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = cur.left;
                         }
@@ -150,7 +127,6 @@ var BST = /** @class */ (function (_super) {
                             //Add to the right of the current node
                             cur.right = newNode;
                             this._setSize(this.size + 1);
-                            this._setCount(this.count + newNode.count);
                             traversing = false;
                             inserted = (cur.right);
                         }
@@ -169,13 +145,12 @@ var BST = /** @class */ (function (_super) {
         return inserted;
     };
     /**
-     * The `get` function returns the first node in a binary search tree that matches the given property value or name.
+     * The function returns the first node in a binary tree that matches the given property name and value.
      * @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.
+     * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @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 N object or null.
+     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'id'`.
+     * @returns The method is returning either a BinaryTreeNodeId or N (generic type) or null.
      */
     BST.prototype.get = function (nodeProperty, propertyName) {
         var _a;
@@ -185,10 +160,9 @@ var BST = /** @class */ (function (_super) {
     /**
      * 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.
-     * @returns The function `lastKey()` returns the ID of the rightmost node in a binary tree. If the comparison between
-     * the first two elements in the tree is less than, it returns the ID of the rightmost node. If the comparison is
-     * greater than, it returns the ID of the leftmost node. Otherwise, it also returns the ID of the rightmost node. If
-     * there are no nodes in
+     * @returns The method `lastKey()` returns the id of the rightmost node in the binary tree if the comparison between
+     * the values at index 0 and 1 is less than, otherwise it returns the id of the leftmost node. If the comparison is
+     * equal, it returns the id of the rightmost node. If there are no nodes in the tree, it returns 0.
      */
     BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
@@ -200,17 +174,15 @@ var BST = /** @class */ (function (_super) {
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
     };
     /**
-     * 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 | 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.
+     * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or an
+     * `N` type. It represents the property of the binary tree node that you want to compare with.
      * @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 N objects.
+     * specifies the property name to use for comparison. If not provided, it defaults to `'id'`.
+     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
+     * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
+     * is set to `true`, the function will return an array with only one node (if
+     * @returns an array of nodes (type N).
      */
     BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
@@ -261,13 +233,13 @@ var BST = /** @class */ (function (_super) {
     };
     // --- start additional functions
     /**
-     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a lesser value
-     * than a given node.
+     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
+     * less than a given node.
      * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in a binary
-     * tree that have a lesser value than the specified `beginNode` based on the specified `propertyName`.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
+     * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
      */
     BST.prototype.lesserSum = function (beginNode, propertyName) {
         var _this = this;
@@ -285,9 +257,6 @@ var BST = /** @class */ (function (_super) {
                 case 'id':
                     needSum = cur.id;
                     break;
-                case 'count':
-                    needSum = cur.count;
-                    break;
                 default:
                     needSum = cur.id;
                     break;
@@ -353,15 +322,15 @@ var BST = /** @class */ (function (_super) {
         return sum;
     };
     /**
-     * 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 `N`, which represents a node in a binary search tree. It
-     * contains properties such as `id` and `count`.
+     * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
+     * have a greater value than a given node.
+     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be either of type `N` (a generic type),
+     * `BinaryTreeNodeId`, or `null`. It represents the node in the binary tree to which the delta value will be added.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
-     * each node should be increased.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
-     * property of the BSTNode to be modified. It can be either 'id' or 'count'. If propertyName is not provided, it
-     * defaults to 'id'.
+     * each greater node should be increased.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
+     * 'id'.
      * @returns a boolean value.
      */
     BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
@@ -379,9 +348,6 @@ var BST = /** @class */ (function (_super) {
                 case 'id':
                     cur.id += delta;
                     break;
-                case 'count':
-                    cur.count += delta;
-                    break;
                 default:
                     cur.id += delta;
                     break;
@@ -390,12 +356,13 @@ var BST = /** @class */ (function (_super) {
         if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_3 = function (cur) {
                 var compared = _this._compare(cur.id, id);
-                _sumByPropertyName(cur);
+                if (compared === types_1.CP.gt)
+                    _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && compared === types_1.CP.gt)
+                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
                     _traverse_3(cur.left);
-                else if (cur.right && compared === types_1.CP.gt)
+                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
                     _traverse_3(cur.right);
             };
             _traverse_3(this.root);
@@ -406,11 +373,12 @@ var BST = /** @class */ (function (_super) {
             while (queue.length > 0) {
                 var cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.id, node.id);
-                    _sumByPropertyName(cur);
-                    if (cur.left && compared === types_1.CP.gt)
+                    var compared = this._compare(cur.id, id);
+                    if (compared === types_1.CP.gt)
+                        _sumByPropertyName(cur);
+                    if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
                         queue.push(cur.left);
-                    else if (cur.right && compared === types_1.CP.gt)
+                    if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
                         queue.push(cur.right);
                 }
             }
@@ -418,11 +386,20 @@ var BST = /** @class */ (function (_super) {
         }
     };
     /**
-     * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
-     * recursive or iterative approach.
-     * @returns The `balance()` function returns a boolean value.
+     * Balancing Adjustment:
+     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
+     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+     *
+     * Use Cases and Efficiency:
+     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
      */
-    BST.prototype.balance = function () {
+    /**
+     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
+     * constructs a balanced binary search tree using either a recursive or iterative approach.
+     * @returns The function `perfectlyBalance()` returns a boolean value.
+     */
+    BST.prototype.perfectlyBalance = function () {
         var _this = this;
         var sorted = this.DFS('in', 'node'), n = sorted.length;
         this.clear();
@@ -434,7 +411,7 @@ var BST = /** @class */ (function (_super) {
                     return;
                 var m = l + Math.floor((r - l) / 2);
                 var midNode = sorted[m];
-                _this.add(midNode.id, midNode.val, midNode.count);
+                _this.add(midNode.id, midNode.val);
                 buildBalanceBST_1(l, m - 1);
                 buildBalanceBST_1(m + 1, r);
             };
@@ -450,7 +427,7 @@ var BST = /** @class */ (function (_super) {
                     if (l <= r) {
                         var m = l + Math.floor((r - l) / 2);
                         var midNode = sorted[m];
-                        this.add(midNode.id, midNode.val, midNode.count);
+                        this.add(midNode.id, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -460,9 +437,8 @@ var BST = /** @class */ (function (_super) {
         }
     };
     /**
-     * The function `isAVLBalanced` checks if a binary search tree is balanced according to the AVL tree property.
-     * @returns The function `isAVLBalanced()` returns a boolean value. It returns `true` if the binary search tree (BST)
-     * is balanced according to the AVL tree property, and `false` otherwise.
+     * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
+     * @returns a boolean value.
      */
     BST.prototype.isAVLBalanced = function () {
         var _a, _b;

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

@@ -1,26 +1,15 @@
 import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../types';
 import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
 import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<T = any, FAMILY extends RBTreeNode<T, FAMILY> = RBTreeNodeNested<T>> extends BSTNode<T, FAMILY> implements IRBTreeNode<T, FAMILY> {
-    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+export declare class RBTreeNode<T = any, NEIGHBOR extends RBTreeNode<T, NEIGHBOR> = RBTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IRBTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, color: RBColor, val?: T);
     private _color;
     get color(): RBColor;
     set color(value: RBColor);
-    /**
-     * The function creates a new RBTreeNode with the given id, value, and count and returns it as a FAMILY object.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param {T | null} [val] - The "val" parameter represents the value to be stored in the node. It can be of type T
-     * (generic type) or null.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
-     * node.
-     * @returns The method is returning a new instance of the RBTreeNode class, casted as a FAMILY type.
-     */
-    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
     constructor(options?: RBTreeOptions);
-    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
     insert(id: number, val?: N | null): void;
     private leftRotate;
     private rightRotate;

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

@@ -20,9 +20,10 @@ var types_1 = require("../types");
 var bst_1 = require("./bst");
 var RBTreeNode = /** @class */ (function (_super) {
     __extends(RBTreeNode, _super);
-    function RBTreeNode(id, val, count) {
-        var _this = _super.call(this, id, val, count) || this;
+    function RBTreeNode(id, color, val) {
+        var _this = _super.call(this, id, val) || this;
         _this._color = types_1.RBColor.RED;
+        _this._color = color;
         return _this;
     }
     Object.defineProperty(RBTreeNode.prototype, "color", {
@@ -35,19 +36,6 @@ var RBTreeNode = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
-    /**
-     * The function creates a new RBTreeNode with the given id, value, and count and returns it as a FAMILY object.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param {T | null} [val] - The "val" parameter represents the value to be stored in the node. It can be of type T
-     * (generic type) or null.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
-     * node.
-     * @returns The method is returning a new instance of the RBTreeNode class, casted as a FAMILY type.
-     */
-    RBTreeNode.prototype.createNode = function (id, val, count) {
-        return new RBTreeNode(id, val, count);
-    };
     return RBTreeNode;
 }(bst_1.BSTNode));
 exports.RBTreeNode = RBTreeNode;
@@ -56,8 +44,8 @@ var RBTree = /** @class */ (function (_super) {
     function RBTree(options) {
         return _super.call(this, options) || this;
     }
-    RBTree.prototype.createNode = function (id, val, count) {
-        return new RBTreeNode(id, val, count);
+    RBTree.prototype.createNode = function (id, val) {
+        return new RBTreeNode(id, types_1.RBColor.RED, val);
     };
     // private override _root: BinaryTreeNode<N> | null = null;
     //

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

@@ -5,27 +5,39 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, TreeMultiSetNodeNested, TreeMultiSetOptions } from '../types';
-import { ITreeMultiSet, ITreeMultiSetNode } from '../interfaces';
+import type { BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions } from '../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern, NodeOrPropertyName } from '../types';
+import { ITreeMultiset, ITreeMultisetNode } from '../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultiSetNode<T = any, FAMILY extends TreeMultiSetNode<T, FAMILY> = TreeMultiSetNodeNested<T>> extends AVLTreeNode<T, FAMILY> implements ITreeMultiSetNode<T, FAMILY> {
-    /**
-     * The function creates a new node in a binary tree with an optional value and count.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the tree.
-     * @param {T} [val] - The `val` parameter represents the value to be stored in the node. It is an optional parameter,
-     * meaning it can be omitted when calling the `createNode` method.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of the value in the binary tree
-     * node. It is an optional parameter, so it can be omitted when calling the `createNode` method.
-     * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
-     */
-    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
+export declare class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIGHBOR> = TreeMultisetNodeNested<T>> extends AVLTreeNode<T, NEIGHBOR> implements ITreeMultisetNode<T, NEIGHBOR> {
+    /**
+     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * of the binary tree node.
+     * @param {T} [val] - The `val` parameter is an optional parameter of type `T`. It represents the value of the binary
+     * tree node. If no value is provided, it will be `undefined`.
+     * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
+     * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
+     * parameter when creating a new instance of the `BinaryTreeNode` class,
+     */
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
+    private _count;
+    get count(): number;
+    set count(v: number);
 }
 /**
- * The only distinction between a TreeMultiSet and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiSet<N extends TreeMultiSetNode<N['val'], N> = TreeMultiSetNode> extends AVLTree<N> implements ITreeMultiSet<N> {
-    constructor(options?: TreeMultiSetOptions);
+export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode> extends AVLTree<N> implements ITreeMultiset<N> {
+    /**
+     * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
+     * merge duplicated values.
+     * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
+     * TreeMultiset.
+     */
+    constructor(options?: TreeMultisetOptions);
+    private _count;
+    get count(): number;
     /**
      * 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
@@ -36,4 +48,161 @@ export declare class TreeMultiSet<N extends TreeMultiSetNode<N['val'], N> = Tree
      * @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 swaps the location of two nodes in a tree data structure.
+     * @param {N} srcNode - The source node that we want to swap with the destination node.
+     * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+     * be swapped with.
+     * @returns the `destNode` after swapping its values with the `srcNode`.
+     */
+    swapLocation(srcNode: N, destNode: N): N;
+    /**
+     * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
+     * balancing the tree if necessary.
+     * @param {BinaryTreeNodeId} id - The id parameter represents the identifier of the binary tree node that we want to
+     * add. It is of type BinaryTreeNodeId.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
+     * provided, it will default to `undefined`.
+     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the node
+     * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
+     * @returns The `add` method returns the inserted node (`N`), `null`, or `undefined`.
+     */
+    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined;
+    /**
+     * The function adds a new node to a binary tree as the left or right child of a given parent node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
+     * either a node object (`N`) or `null`.
+     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
+     * child.
+     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
+     * `undefined` in certain cases.
+     */
+    addTo(newNode: N | null, parent: N): N | null | undefined;
+    /**
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * null/undefined values.
+     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
+     * array of `N` objects.
+     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     */
+    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
+    /**
+     * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
+     * node that needs to be balanced.
+     * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
+     * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
+     * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
+     * not be taken into account when removing it. If `ignoreCount` is set to `false
+     * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
+     */
+    remove(nodeOrId: N | BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    /**
+     * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
+     * recursive or iterative traversal.
+     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
+     * binary tree.
+     * @returns The function `getSubTreeCount` returns an array `[number, number]`.
+     */
+    getSubTreeCount(subTreeRoot: N | null | undefined): [number, number];
+    /**
+     * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
+     * recursively or iteratively.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree) or
+     * `null` if the subtree is empty.
+     * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
+     */
+    subTreeSumCount(subTreeRoot: N | BinaryTreeNodeId | null): number;
+    /**
+     * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
+     * the `count` property of each node.
+     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree), a
+     * `BinaryTreeNode` object, or `null` if the subtree is empty.
+     * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
+     * in the subtree should be increased or decreased.
+     * @returns a boolean value.
+     */
+    subTreeAddCount(subTreeRoot: N | BinaryTreeNodeId | null, delta: number): boolean;
+    /**
+     * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
+     * using a queue.
+     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * `N`. It represents the property of the nodes that you want to search for.
+     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
+     * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
+     * to `true`, the function will return only one node. If `onlyOne`
+     * @returns an array of nodes that match the given nodeProperty.
+     */
+    getNodesByCount(nodeProperty: BinaryTreeNodeId | N, onlyOne?: boolean): N[];
+    /**
+     * The BFSCount function returns an array of counts from a breadth-first search of nodes.
+     * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
+     * BFS traversal.
+     */
+    BFSCount(): number[];
+    /**
+     * The function "listLevelsCount" takes a node and returns an array of arrays, where each inner array contains the
+     * count property of each node at that level.
+     * @param {N | null} node - The parameter `node` is of type `N | null`. This means that it can either be an instance of
+     * the class `N` or `null`.
+     * @returns a 2D array of numbers. Each inner array represents a level in the binary tree, and each number in the inner
+     * array represents the count property of a node in that level.
+     */
+    listLevelsCount(node: N | null): number[][];
+    /**
+     * The `morrisCount` function returns an array of counts for each node in a binary tree, based on a specified traversal
+     * pattern.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The `pattern` parameter is an optional parameter that specifies the
+     * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
+     * @returns The function `morrisCount` returns an array of numbers.
+     */
+    morrisCount(pattern?: 'in' | 'pre' | 'post'): number[];
+    /**
+     * The function DFSIterativeCount performs a depth-first search iteratively and returns an array of count values for
+     * each node.
+     * @param {'in' | 'pre' | 'post'} [pattern] - The "pattern" parameter is a string that specifies the traversal order
+     * for the Depth-First Search (DFS) algorithm. It can have one of three values: 'in', 'pre', or 'post'.
+     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
+     * specifies whether to return the nodes or the property names during the depth-first search traversal. If it is set to
+     * `'node'`, the function will return the nodes. If it is set to `'property'`, the function will return the property
+     * @returns The DFSIterativeCount method returns an array of numbers.
+     */
+    DFSIterativeCount(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): number[];
+    /**
+     * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
+     * @param {DFSOrderPattern} [pattern] - The `pattern` parameter is an optional parameter that specifies the order in
+     * which the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
+     * @param [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is used to specify whether you want to retrieve the
+     * nodes themselves or a specific property of the nodes. If you pass `'count'` as the value for `nodeOrPropertyName`,
+     * the function will return an array of the `count` property of each node.
+     * @returns The DFSCount method returns an array of numbers representing the count property of each node in the DFS
+     * traversal.
+     */
+    DFSCount(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    /**
+     * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
+     * value than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
+     */
+    lesserSumCount(beginNode: N | BinaryTreeNodeId | null): number;
+    /**
+     * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
+     * greater than a given ID by a specified delta value.
+     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be one of the following:
+     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
+     * of each node should be increased.
+     * @returns a boolean value.
+     */
+    allGreaterNodesAddCount(node: N | BinaryTreeNodeId | null, delta: number): boolean;
+    /**
+     * The clear() function clears the data and sets the count to 0.
+     */
+    clear(): void;
+    /**
+     * The function "_setCount" is used to set the value of the "_count" property.
+     * @param {number} v - number
+     */
+    protected _setCount(v: number): void;
 }