data-structure-typed 1.34.7 → 1.34.9

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

@@ -1,225 +1,118 @@
 "use strict";
-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.AbstractBinaryTree = exports.AbstractBinaryTreeNode = void 0;
-var utils_1 = require("../../utils");
-var types_1 = require("../../types");
-var AbstractBinaryTreeNode = (function () {
-    function AbstractBinaryTreeNode(id, val) {
-        this._height = 0;
-        this._id = id;
-        this._val = val;
-    }
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "id", {
-        get: function () {
-            return this._id;
-        },
-        set: function (v) {
-            this._id = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "val", {
-        get: function () {
-            return this._val;
-        },
-        set: function (value) {
-            this._val = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "left", {
-        get: function () {
-            return this._left;
-        },
-        set: function (v) {
-            if (v) {
-                v.parent = this;
-            }
-            this._left = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "right", {
-        get: function () {
-            return this._right;
-        },
-        set: function (v) {
-            if (v) {
-                v.parent = this;
-            }
-            this._right = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "parent", {
-        get: function () {
-            return this._parent;
-        },
-        set: function (v) {
-            this._parent = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "height", {
-        get: function () {
-            return this._height;
-        },
-        set: function (v) {
-            this._height = v;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTreeNode.prototype, "familyPosition", {
-        get: function () {
-            var that = this;
-            if (that.parent) {
-                if (that.parent.left === that) {
-                    if (that.left || that.right) {
-                        return types_1.FamilyPosition.ROOT_LEFT;
-                    }
-                    else {
-                        return types_1.FamilyPosition.LEFT;
-                    }
-                }
-                else if (that.parent.right === that) {
-                    if (that.left || that.right) {
-                        return types_1.FamilyPosition.ROOT_RIGHT;
-                    }
-                    else {
-                        return types_1.FamilyPosition.RIGHT;
-                    }
+const utils_1 = require("../../utils");
+const types_1 = require("../../types");
+class AbstractBinaryTreeNode {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+    }
+    get left() {
+        return this._left;
+    }
+    set left(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._left = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._right = v;
+    }
+    get familyPosition() {
+        const that = this;
+        if (that.parent) {
+            if (that.parent.left === that) {
+                if (that.left || that.right) {
+                    return types_1.FamilyPosition.ROOT_LEFT;
                 }
                 else {
-                    return types_1.FamilyPosition.MAL_NODE;
+                    return types_1.FamilyPosition.LEFT;
                 }
             }
-            else {
+            else if (that.parent.right === that) {
                 if (that.left || that.right) {
-                    return types_1.FamilyPosition.ROOT;
+                    return types_1.FamilyPosition.ROOT_RIGHT;
                 }
                 else {
-                    return types_1.FamilyPosition.ISOLATED;
+                    return types_1.FamilyPosition.RIGHT;
                 }
             }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return AbstractBinaryTreeNode;
-}());
+            else {
+                return types_1.FamilyPosition.MAL_NODE;
+            }
+        }
+        else {
+            if (that.left || that.right) {
+                return types_1.FamilyPosition.ROOT;
+            }
+            else {
+                return types_1.FamilyPosition.ISOLATED;
+            }
+        }
+    }
+}
 exports.AbstractBinaryTreeNode = AbstractBinaryTreeNode;
-var AbstractBinaryTree = (function () {
-    function AbstractBinaryTree(options) {
+class AbstractBinaryTree {
+    constructor(options) {
         this._root = null;
         this._size = 0;
         this._loopType = types_1.LoopType.ITERATIVE;
-        this._visitedId = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
+        this.visitedKey = [];
+        this.visitedVal = [];
+        this.visitedNode = [];
         if (options !== undefined) {
-            var _a = options.loopType, loopType = _a === void 0 ? types_1.LoopType.ITERATIVE : _a;
+            const { loopType = types_1.LoopType.ITERATIVE } = options;
             this._loopType = loopType;
         }
         this.clear();
     }
-    Object.defineProperty(AbstractBinaryTree.prototype, "root", {
-        get: function () {
-            return this._root;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "size", {
-        get: function () {
-            return this._size;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "loopType", {
-        get: function () {
-            return this._loopType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedId", {
-        get: function () {
-            return this._visitedId;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedVal", {
-        get: function () {
-            return this._visitedVal;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractBinaryTree.prototype, "visitedNode", {
-        get: function () {
-            return this._visitedNode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    AbstractBinaryTree.prototype.swapLocation = function (srcNode, destNode) {
-        var id = destNode.id, val = destNode.val, height = destNode.height;
-        var tempNode = this.createNode(id, val);
+    get root() {
+        return this._root;
+    }
+    get size() {
+        return this._size;
+    }
+    get loopType() {
+        return this._loopType;
+    }
+    swapLocation(srcNode, destNode) {
+        const { key, val } = destNode;
+        const tempNode = this.createNode(key, val);
         if (tempNode) {
-            tempNode.height = height;
-            destNode.id = srcNode.id;
+            destNode.key = srcNode.key;
             destNode.val = srcNode.val;
-            destNode.height = srcNode.height;
-            srcNode.id = tempNode.id;
+            srcNode.key = tempNode.key;
             srcNode.val = tempNode.val;
-            srcNode.height = tempNode.height;
         }
         return destNode;
-    };
-    AbstractBinaryTree.prototype.clear = function () {
+    }
+    clear() {
         this._root = null;
         this._size = 0;
         this._clearResults();
-    };
-    AbstractBinaryTree.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this.size === 0;
-    };
-    AbstractBinaryTree.prototype.add = function (idOrNode, val) {
-        var _this = this;
-        var _bfs = function (root, newNode) {
-            var queue = [root];
+    }
+    add(keyOrNode, val) {
+        const _bfs = (root, newNode) => {
+            const queue = [root];
             while (queue.length > 0) {
-                var cur = queue.shift();
+                const cur = queue.shift();
                 if (cur) {
-                    if (newNode && cur.id === newNode.id)
+                    if (newNode && cur.key === newNode.key)
                         return;
-                    var inserted_1 = _this._addTo(newNode, cur);
-                    if (inserted_1 !== undefined)
-                        return inserted_1;
+                    const inserted = this._addTo(newNode, cur);
+                    if (inserted !== undefined)
+                        return inserted;
                     if (cur.left)
                         queue.push(cur.left);
                     if (cur.right)
@@ -230,20 +123,20 @@ var AbstractBinaryTree = (function () {
             }
             return;
         };
-        var inserted, needInsert;
-        if (idOrNode === null) {
+        let inserted, needInsert;
+        if (keyOrNode === null) {
             needInsert = null;
         }
-        else if (typeof idOrNode === 'number') {
-            needInsert = this.createNode(idOrNode, val);
+        else if (typeof keyOrNode === 'number') {
+            needInsert = this.createNode(keyOrNode, val);
         }
-        else if (idOrNode instanceof AbstractBinaryTreeNode) {
-            needInsert = idOrNode;
+        else if (keyOrNode instanceof AbstractBinaryTreeNode) {
+            needInsert = keyOrNode;
         }
         else {
             return;
         }
-        var existNode = idOrNode ? this.get(idOrNode, 'id') : undefined;
+        const existNode = keyOrNode ? this.get(keyOrNode, 'key') : undefined;
         if (this.root) {
             if (existNode) {
                 existNode.val = val;
@@ -264,44 +157,44 @@ var AbstractBinaryTree = (function () {
             inserted = this.root;
         }
         return inserted;
-    };
-    AbstractBinaryTree.prototype.addMany = function (idsOrNodes, data) {
-        var inserted = [];
-        for (var i = 0; i < idsOrNodes.length; i++) {
-            var idOrNode = idsOrNodes[i];
-            if (idOrNode instanceof AbstractBinaryTreeNode) {
-                inserted.push(this.add(idOrNode.id, idOrNode.val));
+    }
+    addMany(keysOrNodes, data) {
+        const inserted = [];
+        for (let i = 0; i < keysOrNodes.length; i++) {
+            const keyOrNode = keysOrNodes[i];
+            if (keyOrNode instanceof AbstractBinaryTreeNode) {
+                inserted.push(this.add(keyOrNode.key, keyOrNode.val));
                 continue;
             }
-            if (idOrNode === null) {
+            if (keyOrNode === null) {
                 inserted.push(this.add(null));
                 continue;
             }
-            var val = data === null || data === void 0 ? void 0 : data[i];
-            inserted.push(this.add(idOrNode, val));
+            const val = data === null || data === void 0 ? void 0 : data[i];
+            inserted.push(this.add(keyOrNode, val));
         }
         return inserted;
-    };
-    AbstractBinaryTree.prototype.fill = function (idsOrNodes, data) {
+    }
+    refill(keysOrNodes, data) {
         this.clear();
-        return idsOrNodes.length === this.addMany(idsOrNodes, data).length;
-    };
-    AbstractBinaryTree.prototype.remove = function (nodeOrId) {
-        var bstDeletedResult = [];
+        return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
+    }
+    remove(nodeOrKey) {
+        const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        var curr = typeof nodeOrId === 'number' ? this.get(nodeOrId) : nodeOrId;
+        const curr = typeof nodeOrKey === 'number' ? this.get(nodeOrKey) : 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.left) {
             if (!parent) {
                 if (curr.right !== undefined)
                     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;
                 }
@@ -312,9 +205,9 @@ var AbstractBinaryTree = (function () {
             }
         }
         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)
@@ -326,43 +219,42 @@ var AbstractBinaryTree = (function () {
             }
         }
         this._setSize(this.size - 1);
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
         return bstDeletedResult;
-    };
-    AbstractBinaryTree.prototype.getDepth = function (beginRoot) {
+    }
+    getDepth(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'id');
-        var depth = 0;
+            beginRoot = this.get(beginRoot, 'key');
+        let depth = 0;
         while (beginRoot === null || beginRoot === void 0 ? void 0 : beginRoot.parent) {
             depth++;
             beginRoot = beginRoot.parent;
         }
         return depth;
-    };
-    AbstractBinaryTree.prototype.getHeight = function (beginRoot) {
-        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+    }
+    getHeight(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'id');
+            beginRoot = this.get(beginRoot, 'key');
         if (!beginRoot)
             return -1;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _getMaxHeight_1 = function (cur) {
+            const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
-                var leftHeight = _getMaxHeight_1(cur.left);
-                var rightHeight = _getMaxHeight_1(cur.right);
+                const leftHeight = _getMaxHeight(cur.left);
+                const rightHeight = _getMaxHeight(cur.right);
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            return _getMaxHeight_1(beginRoot);
+            return _getMaxHeight(beginRoot);
         }
         else {
             if (!beginRoot) {
                 return -1;
             }
-            var stack = [{ node: beginRoot, depth: 0 }];
-            var maxHeight = 0;
+            const stack = [{ node: beginRoot, depth: 0 }];
+            let maxHeight = 0;
             while (stack.length > 0) {
-                var _a = stack.pop(), node = _a.node, depth = _a.depth;
+                const { node, depth } = stack.pop();
                 if (node.left) {
                     stack.push({ node: node.left, depth: depth + 1 });
                 }
@@ -373,28 +265,27 @@ var AbstractBinaryTree = (function () {
             }
             return maxHeight;
         }
-    };
-    AbstractBinaryTree.prototype.getMinHeight = function (beginRoot) {
+    }
+    getMinHeight(beginRoot = this.root) {
         var _a, _b, _c;
-        beginRoot = beginRoot || this.root;
         if (!beginRoot)
             return -1;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _getMinHeight_1 = function (cur) {
+            const _getMinHeight = (cur) => {
                 if (!cur)
                     return 0;
                 if (!cur.left && !cur.right)
                     return 0;
-                var leftMinHeight = _getMinHeight_1(cur.left);
-                var rightMinHeight = _getMinHeight_1(cur.right);
+                const leftMinHeight = _getMinHeight(cur.left);
+                const rightMinHeight = _getMinHeight(cur.right);
                 return Math.min(leftMinHeight, rightMinHeight) + 1;
             };
-            return _getMinHeight_1(beginRoot);
+            return _getMinHeight(beginRoot);
         }
         else {
-            var stack = [];
-            var node = beginRoot, last = null;
-            var depths = new Map();
+            const stack = [];
+            let node = beginRoot, last = null;
+            const depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -405,8 +296,8 @@ var AbstractBinaryTree = (function () {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            var leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            var rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -418,31 +309,29 @@ var AbstractBinaryTree = (function () {
             }
             return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
         }
-    };
-    AbstractBinaryTree.prototype.isPerfectlyBalanced = function (beginRoot) {
+    }
+    isPerfectlyBalanced(beginRoot = this.root) {
         return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
-    };
-    AbstractBinaryTree.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
-        var _this = this;
+    }
+    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
         if (!this.root)
             return [];
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
-        var result = [];
+        const result = [];
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_1 = function (cur) {
-                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            const _traverse = (cur) => {
+                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse_1(cur.left);
-                cur.right && _traverse_1(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_1(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 (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
@@ -452,209 +341,201 @@ var AbstractBinaryTree = (function () {
             }
         }
         return result;
-    };
-    AbstractBinaryTree.prototype.has = function (nodeProperty, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    }
+    has(nodeProperty, propertyName = 'key') {
         return this.getNodes(nodeProperty, propertyName).length > 0;
-    };
-    AbstractBinaryTree.prototype.get = function (nodeProperty, propertyName) {
+    }
+    get(nodeProperty, propertyName = 'key') {
         var _a;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    };
-    AbstractBinaryTree.prototype.getPathToRoot = function (node, isReverse) {
-        if (isReverse === void 0) { isReverse = true; }
-        var result = [];
+    }
+    getPathToRoot(node, isReverse = true) {
+        const result = [];
         while (node.parent) {
             result.push(node);
             node = node.parent;
         }
         result.push(node);
         return isReverse ? result.reverse() : result;
-    };
-    AbstractBinaryTree.prototype.getLeftMost = function (beginRoot) {
+    }
+    getLeftMost(beginRoot = this.root) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'id');
-        beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
+            beginRoot = this.get(beginRoot, 'key');
         if (!beginRoot)
             return beginRoot;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_2 = function (cur) {
+            const _traverse = (cur) => {
                 if (!cur.left)
                     return cur;
-                return _traverse_2(cur.left);
+                return _traverse(cur.left);
             };
-            return _traverse_2(beginRoot);
+            return _traverse(beginRoot);
         }
         else {
-            var _traverse_3 = (0, utils_1.trampoline)(function (cur) {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.left)
                     return cur;
-                return _traverse_3.cont(cur.left);
+                return _traverse.cont(cur.left);
             });
-            return _traverse_3(beginRoot);
+            return _traverse(beginRoot);
         }
-    };
-    AbstractBinaryTree.prototype.getRightMost = function (node) {
-        node = node !== null && node !== void 0 ? node : this.root;
-        if (!node)
-            return node;
+    }
+    getRightMost(beginRoot = this.root) {
+        if (!beginRoot)
+            return beginRoot;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_4 = function (cur) {
+            const _traverse = (cur) => {
                 if (!cur.right)
                     return cur;
-                return _traverse_4(cur.right);
+                return _traverse(cur.right);
             };
-            return _traverse_4(node);
+            return _traverse(beginRoot);
         }
         else {
-            var _traverse_5 = (0, utils_1.trampoline)(function (cur) {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.right)
                     return cur;
-                return _traverse_5.cont(cur.right);
+                return _traverse.cont(cur.right);
             });
-            return _traverse_5(node);
+            return _traverse(beginRoot);
         }
-    };
-    AbstractBinaryTree.prototype.isSubtreeBST = function (node) {
+    }
+    isSubtreeBST(node) {
         if (!node)
             return true;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var dfs_1 = function (cur, min, max) {
+            const dfs = (cur, min, max) => {
                 if (!cur)
                     return true;
-                if (cur.id <= min || cur.id >= max)
+                if (cur.key <= min || cur.key >= max)
                     return false;
-                return dfs_1(cur.left, min, cur.id) && dfs_1(cur.right, cur.id, max);
+                return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, max);
             };
-            return dfs_1(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            return dfs(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
         }
         else {
-            var stack = [];
-            var prev = Number.MIN_SAFE_INTEGER, curr = node;
+            const stack = [];
+            let prev = Number.MIN_SAFE_INTEGER, curr = node;
             while (curr || stack.length > 0) {
                 while (curr) {
                     stack.push(curr);
                     curr = curr.left;
                 }
                 curr = stack.pop();
-                if (!curr || prev >= curr.id)
+                if (!curr || prev >= curr.key)
                     return false;
-                prev = curr.id;
+                prev = curr.key;
                 curr = curr.right;
             }
             return true;
         }
-    };
-    AbstractBinaryTree.prototype.isBST = function () {
+    }
+    isBST() {
         return this.isSubtreeBST(this.root);
-    };
-    AbstractBinaryTree.prototype.getSubTreeSize = function (subTreeRoot) {
-        var size = 0;
+    }
+    getSubTreeSize(subTreeRoot) {
+        let size = 0;
         if (!subTreeRoot)
             return size;
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_6 = function (cur) {
+            const _traverse = (cur) => {
                 size++;
-                cur.left && _traverse_6(cur.left);
-                cur.right && _traverse_6(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_6(subTreeRoot);
+            _traverse(subTreeRoot);
             return size;
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 size++;
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
             return size;
         }
-    };
-    AbstractBinaryTree.prototype.subTreeSum = function (subTreeRoot, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    }
+    subTreeSum(subTreeRoot, propertyName = 'key') {
         if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'id');
+            subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return 0;
-        var sum = 0;
-        var _sumByProperty = function (cur) {
-            var needSum;
+        let sum = 0;
+        const _sumByProperty = (cur) => {
+            let needSum;
             switch (propertyName) {
-                case 'id':
-                    needSum = cur.id;
+                case 'key':
+                    needSum = cur.key;
                     break;
                 case 'val':
                     needSum = typeof cur.val === 'number' ? cur.val : 0;
                     break;
                 default:
-                    needSum = cur.id;
+                    needSum = cur.key;
                     break;
             }
             return needSum;
         };
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_7 = function (cur) {
+            const _traverse = (cur) => {
                 sum += _sumByProperty(cur);
-                cur.left && _traverse_7(cur.left);
-                cur.right && _traverse_7(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_7(subTreeRoot);
+            _traverse(subTreeRoot);
         }
         else {
-            var stack = [subTreeRoot];
+            const stack = [subTreeRoot];
             while (stack.length > 0) {
-                var cur = stack.pop();
+                const cur = stack.pop();
                 sum += _sumByProperty(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return sum;
-    };
-    AbstractBinaryTree.prototype.subTreeAdd = function (subTreeRoot, delta, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+    }
+    subTreeAdd(subTreeRoot, delta, propertyName = 'key') {
         if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'id');
+            subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return false;
-        var _addByProperty = function (cur) {
+        const _addByProperty = (cur) => {
             switch (propertyName) {
-                case 'id':
-                    cur.id += delta;
+                case 'key':
+                    cur.key += delta;
                     break;
                 default:
-                    cur.id += delta;
+                    cur.key += delta;
                     break;
             }
         };
         if (this._loopType === types_1.LoopType.RECURSIVE) {
-            var _traverse_8 = function (cur) {
+            const _traverse = (cur) => {
                 _addByProperty(cur);
-                cur.left && _traverse_8(cur.left);
-                cur.right && _traverse_8(cur.right);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
             };
-            _traverse_8(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;
-    };
-    AbstractBinaryTree.prototype.BFS = function (nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+    }
+    bfs(nodeOrPropertyName = 'key') {
         this._clearResults();
-        var queue = [this.root];
+        const queue = [this.root];
         while (queue.length !== 0) {
-            var cur = queue.shift();
+            const cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 if ((cur === null || cur === void 0 ? void 0 : cur.left) !== null)
@@ -664,23 +545,20 @@ var AbstractBinaryTree = (function () {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    };
-    AbstractBinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
-        var _this = this;
-        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+    }
+    dfs(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
-        var _traverse = function (node) {
+        const _traverse = (node) => {
             switch (pattern) {
                 case 'in':
                     if (node.left)
                         _traverse(node.left);
-                    _this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
                     if (node.right)
                         _traverse(node.right);
                     break;
                 case 'pre':
-                    _this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
                     if (node.left)
                         _traverse(node.left);
                     if (node.right)
@@ -691,22 +569,20 @@ var AbstractBinaryTree = (function () {
                         _traverse(node.left);
                     if (node.right)
                         _traverse(node.right);
-                    _this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
                     break;
             }
         };
         this.root && _traverse(this.root);
         return this._getResultByPropertyName(nodeOrPropertyName);
-    };
-    AbstractBinaryTree.prototype.DFSIterative = function (pattern, nodeOrPropertyName) {
-        pattern = pattern || 'in';
-        nodeOrPropertyName = nodeOrPropertyName || 'id';
+    }
+    dfsIterative(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
         if (!this.root)
             return this._getResultByPropertyName(nodeOrPropertyName);
-        var stack = [{ opt: 0, node: this.root }];
+        const stack = [{ opt: 0, node: this.root }];
         while (stack.length > 0) {
-            var cur = stack.pop();
+            const cur = stack.pop();
             if (!cur || !cur.node)
                 continue;
             if (cur.opt === 1) {
@@ -738,16 +614,14 @@ var AbstractBinaryTree = (function () {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    };
-    AbstractBinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName || 'id';
-        node = node || this.root;
+    }
+    levelIterative(node = this.root, nodeOrPropertyName = 'key') {
         if (!node)
             return [];
         this._clearResults();
-        var queue = [node];
+        const queue = [node];
         while (queue.length > 0) {
-            var cur = queue.shift();
+            const cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 if (cur.left) {
@@ -759,17 +633,15 @@ var AbstractBinaryTree = (function () {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    };
-    AbstractBinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName || 'id';
-        node = node || this.root;
+    }
+    listLevels(node = this.root, nodeOrPropertyName = 'key') {
         if (!node)
             return [];
-        var levelsNodes = [];
-        var collectByProperty = function (node, level) {
+        const levelsNodes = [];
+        const collectByProperty = (node, level) => {
             switch (nodeOrPropertyName) {
-                case 'id':
-                    levelsNodes[level].push(node.id);
+                case 'key':
+                    levelsNodes[level].push(node.key);
                     break;
                 case 'val':
                     levelsNodes[level].push(node.val);
@@ -778,41 +650,41 @@ var AbstractBinaryTree = (function () {
                     levelsNodes[level].push(node);
                     break;
                 default:
-                    levelsNodes[level].push(node.id);
+                    levelsNodes[level].push(node.key);
                     break;
             }
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
-            var _recursive_1 = function (node, level) {
+            const _recursive = (node, level) => {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
                 collectByProperty(node, level);
                 if (node.left)
-                    _recursive_1(node.left, level + 1);
+                    _recursive(node.left, level + 1);
                 if (node.right)
-                    _recursive_1(node.right, level + 1);
+                    _recursive(node.right, level + 1);
             };
-            _recursive_1(node, 0);
+            _recursive(node, 0);
         }
         else {
-            var stack = [[node, 0]];
+            const stack = [[node, 0]];
             while (stack.length > 0) {
-                var head = stack.pop();
-                var _a = __read(head, 2), node_1 = _a[0], level = _a[1];
+                const head = stack.pop();
+                const [node, level] = head;
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
-                collectByProperty(node_1, level);
-                if (node_1.right)
-                    stack.push([node_1.right, level + 1]);
-                if (node_1.left)
-                    stack.push([node_1.left, level + 1]);
+                collectByProperty(node, level);
+                if (node.right)
+                    stack.push([node.right, level + 1]);
+                if (node.left)
+                    stack.push([node.left, level + 1]);
             }
         }
         return levelsNodes;
-    };
-    AbstractBinaryTree.prototype.getPredecessor = function (node) {
+    }
+    getPredecessor(node) {
         if (node.left) {
-            var predecessor = node.left;
+            let predecessor = node.left;
             while (!predecessor || (predecessor.right && predecessor.right !== node)) {
                 if (predecessor) {
                     predecessor = predecessor.right;
@@ -823,18 +695,15 @@ var AbstractBinaryTree = (function () {
         else {
             return node;
         }
-    };
-    AbstractBinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
-        var _this = this;
+    }
+    morris(pattern = 'in', nodeOrPropertyName = 'key') {
         if (this.root === null)
             return [];
-        pattern = pattern || 'in';
-        nodeOrPropertyName = nodeOrPropertyName || 'id';
         this._clearResults();
-        var cur = this.root;
-        var _reverseEdge = function (node) {
-            var pre = null;
-            var next = null;
+        let cur = this.root;
+        const _reverseEdge = (node) => {
+            let pre = null;
+            let next = null;
             while (node) {
                 next = node.right;
                 node.right = pre;
@@ -843,11 +712,11 @@ var AbstractBinaryTree = (function () {
             }
             return pre;
         };
-        var _printEdge = function (node) {
-            var tail = _reverseEdge(node);
-            var cur = tail;
+        const _printEdge = (node) => {
+            const tail = _reverseEdge(node);
+            let cur = tail;
             while (cur) {
-                _this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 cur = cur.right;
             }
             _reverseEdge(tail);
@@ -856,7 +725,7 @@ var AbstractBinaryTree = (function () {
             case 'in':
                 while (cur) {
                     if (cur.left) {
-                        var predecessor = this.getPredecessor(cur);
+                        const predecessor = this.getPredecessor(cur);
                         if (!predecessor.right) {
                             predecessor.right = cur;
                             cur = cur.left;
@@ -873,7 +742,7 @@ var AbstractBinaryTree = (function () {
             case 'pre':
                 while (cur) {
                     if (cur.left) {
-                        var predecessor = this.getPredecessor(cur);
+                        const predecessor = this.getPredecessor(cur);
                         if (!predecessor.right) {
                             predecessor.right = cur;
                             this._accumulatedByPropertyName(cur, nodeOrPropertyName);
@@ -893,7 +762,7 @@ var AbstractBinaryTree = (function () {
             case 'post':
                 while (cur) {
                     if (cur.left) {
-                        var predecessor = this.getPredecessor(cur);
+                        const predecessor = this.getPredecessor(cur);
                         if (predecessor.right === null) {
                             predecessor.right = cur;
                             cur = cur.left;
@@ -910,8 +779,8 @@ var AbstractBinaryTree = (function () {
                 break;
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    };
-    AbstractBinaryTree.prototype._addTo = function (newNode, parent) {
+    }
+    _addTo(newNode, parent) {
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -934,86 +803,74 @@ var AbstractBinaryTree = (function () {
         else {
             return;
         }
-    };
-    AbstractBinaryTree.prototype._setLoopType = function (value) {
+    }
+    _setLoopType(value) {
         this._loopType = value;
-    };
-    AbstractBinaryTree.prototype._setVisitedId = function (value) {
-        this._visitedId = value;
-    };
-    AbstractBinaryTree.prototype._setVisitedVal = function (value) {
-        this._visitedVal = value;
-    };
-    AbstractBinaryTree.prototype._setVisitedNode = function (value) {
-        this._visitedNode = value;
-    };
-    AbstractBinaryTree.prototype._setRoot = function (v) {
+    }
+    _setRoot(v) {
         if (v) {
             v.parent = undefined;
         }
         this._root = v;
-    };
-    AbstractBinaryTree.prototype._setSize = function (v) {
+    }
+    _setSize(v) {
         this._size = v;
-    };
-    AbstractBinaryTree.prototype._clearResults = function () {
-        this._visitedId = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
-    };
-    AbstractBinaryTree.prototype._pushByPropertyNameStopOrNot = function (cur, result, nodeProperty, propertyName, onlyOne) {
+    }
+    _clearResults() {
+        this.visitedKey = [];
+        this.visitedVal = [];
+        this.visitedNode = [];
+    }
+    _pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName = 'key', onlyOne = false) {
         switch (propertyName) {
-            case 'id':
-                if (cur.id === nodeProperty) {
+            case 'key':
+                if (cur.key === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
             case 'val':
                 if (cur.val === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
             default:
-                if (cur.id === nodeProperty) {
+                if (cur.key === nodeProperty) {
                     result.push(cur);
-                    return !!onlyOne;
+                    return onlyOne;
                 }
                 break;
         }
-    };
-    AbstractBinaryTree.prototype._accumulatedByPropertyName = function (node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+    }
+    _accumulatedByPropertyName(node, nodeOrPropertyName = 'key') {
         switch (nodeOrPropertyName) {
-            case 'id':
-                this._visitedId.push(node.id);
+            case 'key':
+                this.visitedKey.push(node.key);
                 break;
             case 'val':
-                this._visitedVal.push(node.val);
+                this.visitedVal.push(node.val);
                 break;
             case 'node':
-                this._visitedNode.push(node);
+                this.visitedNode.push(node);
                 break;
             default:
-                this._visitedId.push(node.id);
+                this.visitedKey.push(node.key);
                 break;
         }
-    };
-    AbstractBinaryTree.prototype._getResultByPropertyName = function (nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+    }
+    _getResultByPropertyName(nodeOrPropertyName = 'key') {
         switch (nodeOrPropertyName) {
-            case 'id':
-                return this._visitedId;
+            case 'key':
+                return this.visitedKey;
             case 'val':
-                return this._visitedVal;
+                return this.visitedVal;
             case 'node':
-                return this._visitedNode;
+                return this.visitedNode;
             default:
-                return this._visitedId;
+                return this.visitedKey;
         }
-    };
-    return AbstractBinaryTree;
-}());
+    }
+}
 exports.AbstractBinaryTree = AbstractBinaryTree;
 //# sourceMappingURL=abstract-binary-tree.js.map