data-structure-typed 1.34.8 → 1.34.9

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

@@ -1,91 +1,29 @@
 "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 __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiset = exports.TreeMultisetNode = void 0;
-var types_1 = require("../../types");
-var avl_tree_1 = require("./avl-tree");
-var TreeMultisetNode = (function (_super) {
-    __extends(TreeMultisetNode, _super);
-    function TreeMultisetNode(key, val, count) {
-        if (count === void 0) { count = 1; }
-        var _this = _super.call(this, key, val) || this;
-        _this._count = count;
-        return _this;
+const types_1 = require("../../types");
+const avl_tree_1 = require("./avl-tree");
+class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
+    constructor(key, val, count = 1) {
+        super(key, val);
+        this.count = count;
     }
-    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;
-var TreeMultiset = (function (_super) {
-    __extends(TreeMultiset, _super);
-    function TreeMultiset(options) {
-        var _this = _super.call(this, __assign({}, options)) || this;
-        _this._count = 0;
-        return _this;
+class TreeMultiset extends avl_tree_1.AVLTree {
+    constructor(options) {
+        super(options);
+        this._count = 0;
     }
-    Object.defineProperty(TreeMultiset.prototype, "count", {
-        get: function () {
-            return this._count;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TreeMultiset.prototype.createNode = function (key, val, count) {
+    get count() {
+        return this._count;
+    }
+    createNode(key, val, count) {
         return new TreeMultisetNode(key, val, count);
-    };
-    TreeMultiset.prototype.swapLocation = function (srcNode, destNode) {
-        var key = destNode.key, val = destNode.val, count = destNode.count, height = destNode.height;
-        var tempNode = this.createNode(key, val, count);
+    }
+    swapLocation(srcNode, destNode) {
+        const { key, val, count, height } = destNode;
+        const tempNode = this.createNode(key, val, count);
         if (tempNode) {
             tempNode.height = height;
             destNode.key = srcNode.key;
@@ -98,10 +36,9 @@ var TreeMultiset = (function (_super) {
             srcNode.height = tempNode.height;
         }
         return destNode;
-    };
-    TreeMultiset.prototype.add = function (keyOrNode, val, count) {
-        count = count !== null && count !== void 0 ? count : 1;
-        var inserted = undefined, newNode;
+    }
+    add(keyOrNode, val, count = 1) {
+        let inserted = undefined, newNode;
         if (keyOrNode instanceof TreeMultisetNode) {
             newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
         }
@@ -118,8 +55,8 @@ var TreeMultiset = (function (_super) {
             inserted = this.root;
         }
         else {
-            var cur = this.root;
-            var traversing = true;
+            let cur = this.root;
+            let traversing = true;
             while (traversing) {
                 if (cur) {
                     if (newNode) {
@@ -168,8 +105,8 @@ var TreeMultiset = (function (_super) {
         if (inserted)
             this._balancePath(inserted);
         return inserted;
-    };
-    TreeMultiset.prototype._addTo = function (newNode, parent) {
+    }
+    _addTo(newNode, parent) {
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -194,11 +131,11 @@ var TreeMultiset = (function (_super) {
         else {
             return;
         }
-    };
-    TreeMultiset.prototype.addMany = function (idsOrNodes, data) {
-        var inserted = [];
-        for (var i = 0; i < idsOrNodes.length; i++) {
-            var keyOrNode = idsOrNodes[i];
+    }
+    addMany(keysOrNodes, data) {
+        const inserted = [];
+        for (let i = 0; i < keysOrNodes.length; i++) {
+            const keyOrNode = keysOrNodes[i];
             if (keyOrNode instanceof TreeMultisetNode) {
                 inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
                 continue;
@@ -210,35 +147,34 @@ var TreeMultiset = (function (_super) {
             inserted.push(this.add(keyOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
         }
         return inserted;
-    };
-    TreeMultiset.prototype.perfectlyBalance = function () {
-        var _this = this;
-        var sorted = this.DFS('in', 'node'), n = sorted.length;
+    }
+    perfectlyBalance() {
+        const sorted = this.dfs('in', 'node'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var buildBalanceBST_1 = function (l, r) {
+            const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
-                var m = l + Math.floor((r - l) / 2);
-                var midNode = sorted[m];
-                _this.add(midNode.key, midNode.val, midNode.count);
-                buildBalanceBST_1(l, m - 1);
-                buildBalanceBST_1(m + 1, r);
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.key, midNode.val, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
             };
-            buildBalanceBST_1(0, n - 1);
+            buildBalanceBST(0, n - 1);
             return true;
         }
         else {
-            var stack = [[0, n - 1]];
+            const stack = [[0, n - 1]];
             while (stack.length > 0) {
-                var popped = stack.pop();
+                const popped = stack.pop();
                 if (popped) {
-                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
+                    const [l, r] = popped;
                     if (l <= r) {
-                        var m = l + Math.floor((r - l) / 2);
-                        var midNode = sorted[m];
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
                         this.add(midNode.key, midNode.val, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -247,16 +183,16 @@ var TreeMultiset = (function (_super) {
             }
             return true;
         }
-    };
-    TreeMultiset.prototype.remove = function (nodeOrKey, ignoreCount) {
-        var bstDeletedResult = [];
+    }
+    remove(nodeOrKey, ignoreCount = false) {
+        const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        var curr = this.get(nodeOrKey);
+        const curr = this.get(nodeOrKey);
         if (!curr)
             return bstDeletedResult;
-        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        var needBalanced = null, orgCurrent = curr;
+        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        let needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
             this._setCount(this.count - 1);
@@ -268,7 +204,7 @@ var TreeMultiset = (function (_super) {
                         this._setRoot(curr.right);
                 }
                 else {
-                    var fp = curr.familyPosition;
+                    const { familyPosition: fp } = curr;
                     if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
                         parent.left = curr.right;
                     }
@@ -279,9 +215,9 @@ var TreeMultiset = (function (_super) {
                 }
             }
             else {
-                var leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
+                const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
                 if (leftSubTreeRightMost) {
-                    var parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
+                    const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
@@ -297,30 +233,30 @@ var TreeMultiset = (function (_super) {
             this._setSize(this.size - 1);
             this._setCount(this.count - orgCurrent.count);
         }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         if (needBalanced) {
             this._balancePath(needBalanced);
         }
         return bstDeletedResult;
-    };
-    TreeMultiset.prototype.getSubTreeCount = function (subTreeRoot) {
-        var res = [0, 0];
+    }
+    getSubTreeCount(subTreeRoot) {
+        const res = [0, 0];
         if (!subTreeRoot)
             return res;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_1 = function (cur) {
+            const _traverse = (cur) => {
                 res[0]++;
                 res[1] += cur.count;
-                cur.left && _traverse_1(cur.left);
-                cur.right && _traverse_1(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_1(subTreeRoot);
+            _traverse(subTreeRoot);
             return res;
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 res[0]++;
                 res[1] += cur.count;
                 cur.right && stack.push(cur.right);
@@ -328,67 +264,66 @@ var TreeMultiset = (function (_super) {
             }
             return res;
         }
-    };
-    TreeMultiset.prototype.subTreeSumCount = function (subTreeRoot) {
+    }
+    subTreeSumCount(subTreeRoot) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return 0;
-        var sum = 0;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_2 = function (cur) {
+            const _traverse = (cur) => {
                 sum += cur.count;
-                cur.left && _traverse_2(cur.left);
-                cur.right && _traverse_2(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_2(subTreeRoot);
+            _traverse(subTreeRoot);
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 sum += cur.count;
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return sum;
-    };
-    TreeMultiset.prototype.subTreeAddCount = function (subTreeRoot, delta) {
-        var _this = this;
+    }
+    subTreeAddCount(subTreeRoot, delta) {
         if (typeof subTreeRoot === 'number')
             subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return false;
-        var _addByProperty = function (cur) {
+        const _addByProperty = (cur) => {
             cur.count += delta;
-            _this._setCount(_this.count + delta);
+            this._setCount(this.count + delta);
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_3 = function (cur) {
+            const _traverse = (cur) => {
                 _addByProperty(cur);
-                cur.left && _traverse_3(cur.left);
-                cur.right && _traverse_3(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_3(subTreeRoot);
+            _traverse(subTreeRoot);
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 _addByProperty(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return true;
-    };
-    TreeMultiset.prototype.getNodesByCount = function (nodeProperty, onlyOne) {
+    }
+    getNodesByCount(nodeProperty, onlyOne = false) {
         if (!this.root)
             return [];
-        var result = [];
+        const result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_4 = function (cur) {
+            const _traverse = (cur) => {
                 if (cur.count === nodeProperty) {
                     result.push(cur);
                     if (onlyOne)
@@ -396,15 +331,15 @@ var TreeMultiset = (function (_super) {
                 }
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse_4(cur.left);
-                cur.right && _traverse_4(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_4(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
                     if (cur.count === nodeProperty) {
                         result.push(cur);
@@ -417,72 +352,68 @@ var TreeMultiset = (function (_super) {
             }
         }
         return result;
-    };
-    TreeMultiset.prototype.BFSCount = function () {
-        var nodes = _super.prototype.BFS.call(this, 'node');
-        return nodes.map(function (node) { return node.count; });
-    };
-    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; }); });
-    };
-    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; });
-    };
-    TreeMultiset.prototype.DFSIterativeCount = function (pattern) {
-        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; });
-    };
-    TreeMultiset.prototype.DFSCount = function (pattern) {
-        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; });
-    };
-    TreeMultiset.prototype.lesserSumCount = function (beginNode) {
-        var _this = this;
+    }
+    BFSCount() {
+        const nodes = super.bfs('node');
+        return nodes.map(node => node.count);
+    }
+    listLevelsCount(node) {
+        const levels = super.listLevels(node, 'node');
+        return levels.map(level => level.map(node => node.count));
+    }
+    morrisCount(pattern = 'in') {
+        const nodes = super.morris(pattern, 'node');
+        return nodes.map(node => node.count);
+    }
+    dfsCountIterative(pattern = 'in') {
+        const nodes = super.dfsIterative(pattern, 'node');
+        return nodes.map(node => node.count);
+    }
+    dfsCount(pattern = 'in') {
+        const nodes = super.dfs(pattern, 'node');
+        return nodes.map(node => node.count);
+    }
+    lesserSumCount(beginNode) {
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'key');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        var key = beginNode.key;
-        var sum = 0;
+        const key = beginNode.key;
+        let sum = 0;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_5 = function (cur) {
-                var compared = _this._compare(cur.key, key);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.key, key);
                 if (compared === types_1.CP.eq) {
                     if (cur.right)
-                        sum += _this.subTreeSumCount(cur.right);
+                        sum += this.subTreeSumCount(cur.right);
                     return;
                 }
                 else if (compared === types_1.CP.lt) {
                     if (cur.left)
-                        sum += _this.subTreeSumCount(cur.left);
+                        sum += this.subTreeSumCount(cur.left);
                     sum += cur.count;
                     if (cur.right)
-                        _traverse_5(cur.right);
+                        _traverse(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse_5(cur.left);
+                        _traverse(cur.left);
                     else
                         return;
                 }
             };
-            _traverse_5(this.root);
+            _traverse(this.root);
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.key, key);
+                    const compared = this._compare(cur.key, key);
                     if (compared === types_1.CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSumCount(cur.right);
@@ -507,37 +438,36 @@ var TreeMultiset = (function (_super) {
             }
         }
         return sum;
-    };
-    TreeMultiset.prototype.allGreaterNodesAddCount = function (node, delta) {
-        var _this = this;
+    }
+    allGreaterNodesAddCount(node, delta) {
         if (typeof node === 'number')
             node = this.get(node, 'key');
         if (!node)
             return false;
-        var key = node.key;
+        const key = node.key;
         if (!this.root)
             return false;
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_6 = function (cur) {
-                var compared = _this._compare(cur.key, key);
+            const _traverse = (cur) => {
+                const compared = this._compare(cur.key, key);
                 if (compared === types_1.CP.gt)
                     cur.count += delta;
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && _this._compare(cur.left.key, key) === types_1.CP.gt)
-                    _traverse_6(cur.left);
-                if (cur.right && _this._compare(cur.right.key, key) === types_1.CP.gt)
-                    _traverse_6(cur.right);
+                if (cur.left && this._compare(cur.left.key, key) === types_1.CP.gt)
+                    _traverse(cur.left);
+                if (cur.right && this._compare(cur.right.key, key) === types_1.CP.gt)
+                    _traverse(cur.right);
             };
-            _traverse_6(this.root);
+            _traverse(this.root);
             return true;
         }
         else {
-            var queue = [this.root];
+            const queue = [this.root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    var compared = this._compare(cur.key, key);
+                    const compared = this._compare(cur.key, key);
                     if (compared === types_1.CP.gt)
                         cur.count += delta;
                     if (cur.left && this._compare(cur.left.key, key) === types_1.CP.gt)
@@ -548,15 +478,14 @@ var TreeMultiset = (function (_super) {
             }
             return true;
         }
-    };
-    TreeMultiset.prototype.clear = function () {
-        _super.prototype.clear.call(this);
+    }
+    clear() {
+        super.clear();
         this._setCount(0);
-    };
-    TreeMultiset.prototype._setCount = function (v) {
+    }
+    _setCount(v) {
         this._count = v;
-    };
-    return TreeMultiset;
-}(avl_tree_1.AVLTree));
+    }
+}
 exports.TreeMultiset = TreeMultiset;
 //# sourceMappingURL=tree-multiset.js.map