data-structure-typed 1.18.8 → 1.19.1

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

@@ -25,38 +25,76 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMultiSet = exports.TreeMultiSetNode = void 0;
+exports.TreeMultiset = exports.TreeMultisetNode = void 0;
+var types_1 = require("../types");
 var avl_tree_1 = require("./avl-tree");
-var TreeMultiSetNode = /** @class */ (function (_super) {
-    __extends(TreeMultiSetNode, _super);
-    function TreeMultiSetNode() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
+var TreeMultisetNode = /** @class */ (function (_super) {
+    __extends(TreeMultisetNode, _super);
     /**
-     * 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.
+     * 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,
      */
-    TreeMultiSetNode.prototype.createNode = function (id, val, count) {
-        return new TreeMultiSetNode(id, val, count);
-    };
-    return TreeMultiSetNode;
+    function TreeMultisetNode(id, val, count) {
+        if (count === void 0) { count = 1; }
+        var _this = _super.call(this, id, val) || this;
+        _this._count = 1;
+        _this._count = count;
+        return _this;
+    }
+    Object.defineProperty(TreeMultisetNode.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        set: function (v) {
+            this._count = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return TreeMultisetNode;
 }(avl_tree_1.AVLTreeNode));
-exports.TreeMultiSetNode = TreeMultiSetNode;
+exports.TreeMultisetNode = TreeMultisetNode;
 /**
- * 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.
  */
-var TreeMultiSet = /** @class */ (function (_super) {
-    __extends(TreeMultiSet, _super);
-    function TreeMultiSet(options) {
-        return _super.call(this, __assign(__assign({}, options), { isMergeDuplicatedVal: true })) || this;
+var TreeMultiset = /** @class */ (function (_super) {
+    __extends(TreeMultiset, _super);
+    /**
+     * 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.
+     */
+    function TreeMultiset(options) {
+        var _this = _super.call(this, __assign(__assign({}, options), { isMergeDuplicatedVal: true })) || this;
+        _this._count = 0;
+        return _this;
     }
+    Object.defineProperty(TreeMultiset.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * 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
@@ -66,9 +104,655 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * 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).
      */
-    TreeMultiSet.prototype.createNode = function (id, val, count) {
-        return new TreeMultiSetNode(id, val, count);
+    TreeMultiset.prototype.createNode = function (id, val, count) {
+        return new TreeMultisetNode(id, val, count);
+    };
+    /**
+     * 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`.
+     */
+    TreeMultiset.prototype.swapLocation = function (srcNode, destNode) {
+        var val = destNode.val, count = destNode.count, height = destNode.height, id = destNode.id;
+        var tempNode = this.createNode(id, val, count);
+        if (tempNode) {
+            tempNode.height = height;
+            if (tempNode instanceof TreeMultisetNode) {
+                destNode.id = srcNode.id;
+                destNode.val = srcNode.val;
+                destNode.count = srcNode.count;
+                destNode.height = srcNode.height;
+                srcNode.id = tempNode.id;
+                srcNode.val = tempNode.val;
+                srcNode.count = tempNode.count;
+                srcNode.height = tempNode.height;
+            }
+        }
+        return destNode;
+    };
+    /**
+     * 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`.
+     */
+    TreeMultiset.prototype.add = function (id, val, count) {
+        count = count !== null && count !== void 0 ? count : 1;
+        var inserted = null;
+        var newNode = this.createNode(id, val, count);
+        if (this.root === null) {
+            this._setRoot(newNode);
+            this._setSize(this.size + 1);
+            this._setCount(this.count + count);
+            inserted = (this.root);
+        }
+        else {
+            var cur = this.root;
+            var traversing = true;
+            while (traversing) {
+                if (cur !== null && newNode !== null) {
+                    if (this._compare(cur.id, id) === types_1.CP.eq) {
+                        if (newNode) {
+                            cur.val = newNode.val;
+                            cur.count += count;
+                            this._setCount(this.count + newNode.count);
+                        }
+                        //Duplicates are not accepted.
+                        traversing = false;
+                        inserted = cur;
+                    }
+                    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;
+                            }
+                            //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;
+                        }
+                        else {
+                            //Traverse the left of the current node
+                            if (cur.left)
+                                cur = cur.left;
+                        }
+                    }
+                    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;
+                            }
+                            //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);
+                        }
+                        else {
+                            //Traverse the left of the current node
+                            if (cur.right)
+                                cur = cur.right;
+                        }
+                    }
+                }
+                else {
+                    traversing = false;
+                }
+            }
+        }
+        if (inserted)
+            this.balancePath(inserted);
+        return inserted;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.addTo = function (newNode, parent) {
+        var _a, _b;
+        if (parent) {
+            if (parent.left === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                }
+                parent.left = newNode;
+                if (newNode !== null) {
+                    this._setSize(this.size + 1);
+                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 0);
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                }
+                parent.right = newNode;
+                if (newNode !== null) {
+                    this._setSize(this.size + 1);
+                    this._setCount((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.addMany = function (data) {
+        var e_1, _a, e_2, _b;
+        var _c;
+        // TODO not sure addMany not be run multi times
+        var inserted = [];
+        var map = new Map();
+        if (this.isMergeDuplicatedVal) {
+            try {
+                for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                    var nodeOrId = data_1_1.value;
+                    map.set(nodeOrId, ((_c = map.get(nodeOrId)) !== null && _c !== void 0 ? _c : 0) + 1);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        try {
+            for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
+                var nodeOrId = data_2_1.value;
+                if (nodeOrId instanceof TreeMultisetNode) {
+                    inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+                    continue;
+                }
+                if (nodeOrId === null) {
+                    inserted.push(this.add(NaN, null, 0));
+                    continue;
+                }
+                // TODO will this cause an issue?
+                var count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
+                var newId = void 0;
+                if (typeof nodeOrId === 'number') {
+                    newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
+                }
+                else if (nodeOrId instanceof Object) {
+                    if (this.autoIncrementId) {
+                        newId = this.maxId + 1;
+                    }
+                    else {
+                        if (Object.keys(nodeOrId).includes('id')) {
+                            newId = nodeOrId.id;
+                        }
+                        else {
+                            console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    console.warn(nodeOrId, " is not added");
+                    continue;
+                }
+                if (this.isMergeDuplicatedVal) {
+                    if (map.has(nodeOrId)) {
+                        inserted.push(this.add(newId, nodeOrId, count));
+                        map.delete(nodeOrId);
+                    }
+                }
+                else {
+                    inserted.push(this.add(newId, nodeOrId, 1));
+                }
+                this._setMaxId(newId);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (data_2_1 && !data_2_1.done && (_b = data_2.return)) _b.call(data_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return inserted;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.remove = function (nodeOrId, ignoreCount) {
+        var bstDeletedResult = [];
+        if (!this.root)
+            return bstDeletedResult;
+        var curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        if (!curr)
+            return bstDeletedResult;
+        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        var needBalanced = null, orgCurrent = curr;
+        if (curr.count > 1 && !ignoreCount) {
+            curr.count--;
+            this._setCount(this.count - 1);
+        }
+        else {
+            if (!curr.left) {
+                if (!parent) {
+                    if (curr.right !== undefined)
+                        this._setRoot(curr.right);
+                }
+                else {
+                    var fp = curr.familyPosition;
+                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                        parent.left = curr.right;
+                    }
+                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                        parent.right = curr.right;
+                    }
+                    needBalanced = parent;
+                }
+            }
+            else {
+                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                if (leftSubTreeRightMost) {
+                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
+                    if (parentOfLeftSubTreeMax) {
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                        else
+                            parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        needBalanced = parentOfLeftSubTreeMax;
+                    }
+                }
+            }
+            this._setSize(this.size - 1);
+            this._setCount(this.count - orgCurrent.count);
+        }
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        if (needBalanced) {
+            this.balancePath(needBalanced);
+        }
+        return bstDeletedResult;
+    };
+    /**
+     * 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]`.
+     */
+    TreeMultiset.prototype.getSubTreeCount = function (subTreeRoot) {
+        var res = [0, 0];
+        if (!subTreeRoot)
+            return res;
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_1 = function (cur) {
+                res[0]++;
+                res[1] += cur.count;
+                cur.left && _traverse_1(cur.left);
+                cur.right && _traverse_1(cur.right);
+            };
+            _traverse_1(subTreeRoot);
+            return res;
+        }
+        else {
+            var stack = [subTreeRoot];
+            while (stack.length > 0) {
+                var cur = stack.pop();
+                res[0]++;
+                res[1] += cur.count;
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+            return res;
+        }
+    };
+    /**
+     * 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`.
+     */
+    TreeMultiset.prototype.subTreeSumCount = function (subTreeRoot) {
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
+        if (!subTreeRoot)
+            return 0;
+        var sum = 0;
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_2 = function (cur) {
+                sum += cur.count;
+                cur.left && _traverse_2(cur.left);
+                cur.right && _traverse_2(cur.right);
+            };
+            _traverse_2(subTreeRoot);
+        }
+        else {
+            var stack = [subTreeRoot];
+            while (stack.length > 0) {
+                var cur = stack.pop();
+                sum += cur.count;
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+        }
+        return sum;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.subTreeAddCount = function (subTreeRoot, delta) {
+        var _this = this;
+        if (typeof subTreeRoot === 'number')
+            subTreeRoot = this.get(subTreeRoot, 'id');
+        if (!subTreeRoot)
+            return false;
+        var _addByProperty = function (cur) {
+            cur.count += delta;
+            _this._setCount(_this.count + delta);
+        };
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_3 = function (cur) {
+                _addByProperty(cur);
+                cur.left && _traverse_3(cur.left);
+                cur.right && _traverse_3(cur.right);
+            };
+            _traverse_3(subTreeRoot);
+        }
+        else {
+            var stack = [subTreeRoot];
+            while (stack.length > 0) {
+                var cur = stack.pop();
+                _addByProperty(cur);
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+        }
+        return true;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.getNodesByCount = function (nodeProperty, onlyOne) {
+        if (!this.root)
+            return [];
+        var result = [];
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_4 = function (cur) {
+                if (cur.count === nodeProperty) {
+                    result.push(cur);
+                    if (onlyOne)
+                        return;
+                }
+                if (!cur.left && !cur.right)
+                    return;
+                cur.left && _traverse_4(cur.left);
+                cur.right && _traverse_4(cur.right);
+            };
+            _traverse_4(this.root);
+        }
+        else {
+            var queue = [this.root];
+            while (queue.length > 0) {
+                var cur = queue.shift();
+                if (cur) {
+                    if (cur.count === nodeProperty) {
+                        result.push(cur);
+                        if (onlyOne)
+                            return result;
+                    }
+                    cur.left && queue.push(cur.left);
+                    cur.right && queue.push(cur.right);
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.BFSCount = function () {
+        var nodes = _super.prototype.BFS.call(this, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.listLevelsCount = function (node) {
+        var levels = _super.prototype.listLevels.call(this, node, 'node');
+        return levels.map(function (level) { return level.map(function (node) { return node.count; }); });
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.morrisCount = function (pattern) {
+        pattern = pattern || 'in';
+        var nodes = _super.prototype.morris.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.DFSIterativeCount = function (pattern, nodeOrPropertyName) {
+        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
+        var nodes = _super.prototype.DFSIterative.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.DFSCount = function (pattern, nodeOrPropertyName) {
+        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
+        var nodes = _super.prototype.DFS.call(this, pattern, 'node');
+        return nodes.map(function (node) { return node.count; });
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.lesserSumCount = function (beginNode) {
+        var _this = this;
+        if (typeof beginNode === 'number')
+            beginNode = this.get(beginNode, 'id');
+        if (!beginNode)
+            return 0;
+        if (!this.root)
+            return 0;
+        var id = beginNode.id;
+        var sum = 0;
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_5 = function (cur) {
+                var compared = _this._compare(cur.id, id);
+                if (compared === types_1.CP.eq) {
+                    if (cur.right)
+                        sum += _this.subTreeSumCount(cur.right);
+                    return;
+                }
+                else if (compared === types_1.CP.lt) {
+                    if (cur.left)
+                        sum += _this.subTreeSumCount(cur.left);
+                    sum += cur.count;
+                    if (cur.right)
+                        _traverse_5(cur.right);
+                    else
+                        return;
+                }
+                else {
+                    if (cur.left)
+                        _traverse_5(cur.left);
+                    else
+                        return;
+                }
+            };
+            _traverse_5(this.root);
+        }
+        else {
+            var queue = [this.root];
+            while (queue.length > 0) {
+                var cur = queue.shift();
+                if (cur) {
+                    var compared = this._compare(cur.id, id);
+                    if (compared === types_1.CP.eq) {
+                        if (cur.right)
+                            sum += this.subTreeSumCount(cur.right);
+                        return sum;
+                    }
+                    else if (compared === types_1.CP.lt) { // todo maybe a bug
+                        if (cur.left)
+                            sum += this.subTreeSumCount(cur.left);
+                        sum += cur.count;
+                        if (cur.right)
+                            queue.push(cur.right);
+                        else
+                            return sum;
+                    }
+                    else {
+                        if (cur.left)
+                            queue.push(cur.left);
+                        else
+                            return sum;
+                    }
+                }
+            }
+        }
+        return sum;
+    };
+    /**
+     * 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.
+     */
+    TreeMultiset.prototype.allGreaterNodesAddCount = function (node, delta) {
+        var _this = this;
+        if (typeof node === 'number')
+            node = this.get(node, 'id');
+        if (!node)
+            return false;
+        var id = node.id;
+        if (!this.root)
+            return false;
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            var _traverse_6 = function (cur) {
+                var compared = _this._compare(cur.id, id);
+                if (compared === types_1.CP.gt)
+                    cur.count += delta;
+                if (!cur.left && !cur.right)
+                    return;
+                if (cur.left && _this._compare(cur.left.id, id) === types_1.CP.gt)
+                    _traverse_6(cur.left);
+                if (cur.right && _this._compare(cur.right.id, id) === types_1.CP.gt)
+                    _traverse_6(cur.right);
+            };
+            _traverse_6(this.root);
+            return true;
+        }
+        else {
+            var queue = [this.root];
+            while (queue.length > 0) {
+                var cur = queue.shift();
+                if (cur) {
+                    var compared = this._compare(cur.id, id);
+                    if (compared === types_1.CP.gt)
+                        cur.count += delta;
+                    if (cur.left && this._compare(cur.left.id, id) === types_1.CP.gt)
+                        queue.push(cur.left);
+                    if (cur.right && this._compare(cur.right.id, id) === types_1.CP.gt)
+                        queue.push(cur.right);
+                }
+            }
+            return true;
+        }
+    };
+    /**
+     * The clear() function clears the data and sets the count to 0.
+     */
+    TreeMultiset.prototype.clear = function () {
+        _super.prototype.clear.call(this);
+        this._setCount(0);
+    };
+    /**
+     * The function "_setCount" is used to set the value of the "_count" property.
+     * @param {number} v - number
+     */
+    TreeMultiset.prototype._setCount = function (v) {
+        this._count = v;
     };
-    return TreeMultiSet;
+    return TreeMultiset;
 }(avl_tree_1.AVLTree));
-exports.TreeMultiSet = TreeMultiSet;
+exports.TreeMultiset = TreeMultiset;