data-structure-typed 0.8.17 → 0.9.16

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

@@ -1,7 +1,34 @@
 "use strict";
+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.");
+};
+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.BinaryTree = exports.BinaryTreeNode = exports.LoopType = exports.FamilyPosition = void 0;
-const trampoline_1 = require("../trampoline");
+var trampoline_1 = require("../trampoline");
 var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition[FamilyPosition["root"] = 0] = "root";
@@ -13,65 +40,8 @@ var LoopType;
     LoopType[LoopType["iterative"] = 1] = "iterative";
     LoopType[LoopType["recursive"] = 2] = "recursive";
 })(LoopType = exports.LoopType || (exports.LoopType = {}));
-class BinaryTreeNode {
-    get id() {
-        return this._id;
-    }
-    set id(v) {
-        this._id = v;
-    }
-    get val() {
-        return this._val;
-    }
-    set val(v) {
-        this._val = v;
-    }
-    get left() {
-        return this._left;
-    }
-    set left(v) {
-        if (v) {
-            v.parent = this;
-            v.familyPosition = FamilyPosition.left;
-        }
-        this._left = v;
-    }
-    get right() {
-        return this._right;
-    }
-    set right(v) {
-        if (v) {
-            v.parent = this;
-            v.familyPosition = FamilyPosition.right;
-        }
-        this._right = v;
-    }
-    get parent() {
-        return this._parent;
-    }
-    set parent(v) {
-        this._parent = v;
-    }
-    get familyPosition() {
-        return this._familyPosition;
-    }
-    set familyPosition(v) {
-        this._familyPosition = v;
-    }
-    get count() {
-        return this._count;
-    }
-    set count(v) {
-        this._count = v;
-    }
-    get height() {
-        return this._height;
-    }
-    set height(v) {
-        this._height = v;
-    }
-    constructor(id, val, count) {
-        this._parent = undefined;
+var BinaryTreeNode = /** @class */ (function () {
+    function BinaryTreeNode(id, val, count) {
         this._familyPosition = FamilyPosition.root;
         this._count = 1;
         this._height = 0;
@@ -79,9 +49,97 @@ class BinaryTreeNode {
         this._val = val;
         this._count = count !== null && count !== void 0 ? count : 1;
     }
-    swapLocation(swapNode) {
-        const { val, count, height } = swapNode;
-        const tempNode = new BinaryTreeNode(swapNode.id, val);
+    Object.defineProperty(BinaryTreeNode.prototype, "id", {
+        get: function () {
+            return this._id;
+        },
+        set: function (v) {
+            this._id = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (v) {
+            this._val = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (v) {
+            if (v) {
+                v.parent = this;
+                v.familyPosition = FamilyPosition.left;
+            }
+            this._left = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (v) {
+            if (v) {
+                v.parent = this;
+                v.familyPosition = FamilyPosition.right;
+            }
+            this._right = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (v) {
+            this._parent = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "familyPosition", {
+        get: function () {
+            return this._familyPosition;
+        },
+        set: function (v) {
+            this._familyPosition = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        set: function (v) {
+            this._count = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTreeNode.prototype, "height", {
+        get: function () {
+            return this._height;
+        },
+        set: function (v) {
+            this._height = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BinaryTreeNode.prototype.swapLocation = function (swapNode) {
+        var val = swapNode.val, count = swapNode.count, height = swapNode.height;
+        var tempNode = new BinaryTreeNode(swapNode.id, val);
         tempNode.val = val;
         tempNode.count = count;
         tempNode.height = height;
@@ -94,76 +152,86 @@ class BinaryTreeNode {
         this.count = tempNode.count;
         this.height = tempNode.height;
         return swapNode;
-    }
-    clone() {
+    };
+    BinaryTreeNode.prototype.clone = function () {
         return new BinaryTreeNode(this.id, this.val, this.count);
-    }
-}
+    };
+    return BinaryTreeNode;
+}());
 exports.BinaryTreeNode = BinaryTreeNode;
-class BinaryTree {
-    get root() {
-        return this._root;
-    }
-    set root(v) {
-        if (v) {
-            v.parent = null;
-            v.familyPosition = FamilyPosition.root;
-        }
-        this._root = v;
-    }
-    get size() {
-        return this._size;
-    }
-    set size(v) {
-        this._size = v;
-    }
-    get count() {
-        return this._count;
-    }
-    set count(v) {
-        this._count = v;
-    }
-    _resetResults() {
+var BinaryTree = /** @class */ (function () {
+    function BinaryTree(options) {
+        this._loopType = LoopType.iterative;
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
         this._visitedCount = [];
         this._visitedLeftSum = [];
-    }
-    constructor(options) {
-        this._root = null;
-        this._size = 0;
-        this._count = 0;
         this._autoIncrementId = false;
         this._maxId = -1;
         this._isDuplicatedVal = false;
-        this._loopType = LoopType.iterative;
-        this._visitedId = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
-        this._visitedCount = [];
-        this._visitedLeftSum = [];
+        this._root = null;
+        this._size = 0;
+        this._count = 0;
         if (options !== undefined) {
-            const { loopType = LoopType.iterative, autoIncrementId = false, isDuplicatedVal = false } = options;
+            var _a = options.loopType, loopType = _a === void 0 ? LoopType.iterative : _a, _b = options.autoIncrementId, autoIncrementId = _b === void 0 ? false : _b, _c = options.isDuplicatedVal, isDuplicatedVal = _c === void 0 ? false : _c;
             this._isDuplicatedVal = isDuplicatedVal;
             this._autoIncrementId = autoIncrementId;
             this._loopType = loopType;
         }
     }
-    createNode(id, val, count) {
+    Object.defineProperty(BinaryTree.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        set: function (v) {
+            if (v) {
+                v.parent = null;
+                v.familyPosition = FamilyPosition.root;
+            }
+            this._root = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        set: function (v) {
+            this._size = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinaryTree.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        set: function (v) {
+            this._count = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BinaryTree.prototype.getCount = function () {
+        return this._count;
+    };
+    BinaryTree.prototype.createNode = function (id, val, count) {
         return val !== null ? new BinaryTreeNode(id, val, count) : null;
-    }
-    clear() {
+    };
+    BinaryTree.prototype.clear = function () {
         this.root = null;
         this.size = 0;
         this.count = 0;
         this._maxId = -1;
-    }
-    isEmpty() {
+    };
+    BinaryTree.prototype.isEmpty = function () {
         return this.size === 0;
-    }
-    insertTo({ newNode, parent }) {
-        var _a, _b;
+    };
+    BinaryTree.prototype.insertTo = function (_a) {
+        var _b, _c;
+        var newNode = _a.newNode, parent = _a.parent;
         if (parent) {
             if (parent.left === undefined) {
                 if (newNode) {
@@ -173,7 +241,7 @@ class BinaryTree {
                 parent.left = newNode;
                 if (newNode !== null) {
                     this.size++;
-                    this.count += (_a = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _a !== void 0 ? _a : 0;
+                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
                 }
                 return parent.left;
             }
@@ -185,7 +253,7 @@ class BinaryTree {
                 parent.right = newNode;
                 if (newNode !== null) {
                     this.size++;
-                    this.count += (_b = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _b !== void 0 ? _b : 0;
+                    this.count += (_c = newNode === null || newNode === void 0 ? void 0 : newNode.count) !== null && _c !== void 0 ? _c : 0;
                 }
                 return parent.right;
             }
@@ -196,17 +264,18 @@ class BinaryTree {
         else {
             return;
         }
-    }
-    put(id, val, count) {
+    };
+    BinaryTree.prototype.put = function (id, val, count) {
+        var _this = this;
         count = count !== null && count !== void 0 ? count : 1;
-        const _bfs = (root, newNode) => {
-            const queue = [root];
+        var _bfs = function (root, newNode) {
+            var queue = [root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const inserted = this.insertTo({ newNode, parent: cur });
-                    if (inserted !== undefined)
-                        return inserted;
+                    var inserted_1 = _this.insertTo({ newNode: newNode, parent: cur });
+                    if (inserted_1 !== undefined)
+                        return inserted_1;
                     if (cur.left)
                         queue.push(cur.left);
                     if (cur.right)
@@ -217,9 +286,9 @@ class BinaryTree {
             }
             return;
         };
-        let inserted;
-        const needInsert = val !== null ? new BinaryTreeNode(id, val, count) : null;
-        const existNode = val !== null ? this.get(id, 'id') : null;
+        var inserted;
+        var needInsert = val !== null ? new BinaryTreeNode(id, val, count) : null;
+        var existNode = val !== null ? this.get(id, 'id') : null;
         if (this.root) {
             if (existNode) {
                 existNode.count += count;
@@ -242,57 +311,79 @@ class BinaryTree {
             inserted = this.root;
         }
         return inserted;
-    }
-    insertMany(data) {
-        var _a;
-        const inserted = [];
-        const map = new Map();
+    };
+    BinaryTree.prototype.insertMany = function (data) {
+        var e_1, _a, e_2, _b;
+        var _c;
+        var inserted = [];
+        var map = new Map();
         if (!this._isDuplicatedVal) {
-            for (const i of data)
-                map.set(i, ((_a = map.get(i)) !== null && _a !== void 0 ? _a : 0) + 1);
-        }
-        for (const item of data) {
-            const count = this._isDuplicatedVal ? 1 : map.get(item);
-            if (item instanceof BinaryTreeNode) {
-                inserted.push(this.put(item.id, item.val, item.count));
-            }
-            else if (typeof item === 'number' && !this._autoIncrementId) {
-                if (!this._isDuplicatedVal) {
-                    if (map.get(item) !== undefined) {
-                        inserted.push(this.put(item, item, count));
-                        map.delete(item);
-                    }
+            try {
+                for (var data_1 = __values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
+                    var i = data_1_1.value;
+                    map.set(i, ((_c = map.get(i)) !== null && _c !== void 0 ? _c : 0) + 1);
                 }
-                else {
-                    inserted.push(this.put(item, item, 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; }
             }
-            else {
-                if (item !== null) {
+        }
+        try {
+            for (var data_2 = __values(data), data_2_1 = data_2.next(); !data_2_1.done; data_2_1 = data_2.next()) {
+                var item = data_2_1.value;
+                var count = this._isDuplicatedVal ? 1 : map.get(item);
+                if (item instanceof BinaryTreeNode) {
+                    inserted.push(this.put(item.id, item.val, item.count));
+                }
+                else if (typeof item === 'number' && !this._autoIncrementId) {
                     if (!this._isDuplicatedVal) {
                         if (map.get(item) !== undefined) {
-                            inserted.push(this.put(++this._maxId, item, count));
+                            inserted.push(this.put(item, item, count));
                             map.delete(item);
                         }
                     }
                     else {
-                        inserted.push(this.put(++this._maxId, item, 1));
+                        inserted.push(this.put(item, item, 1));
                     }
                 }
                 else {
-                    inserted.push(this.put(Number.MAX_SAFE_INTEGER, item, 0));
+                    if (item !== null) {
+                        if (!this._isDuplicatedVal) {
+                            if (map.get(item) !== undefined) {
+                                inserted.push(this.put(++this._maxId, item, count));
+                                map.delete(item);
+                            }
+                        }
+                        else {
+                            inserted.push(this.put(++this._maxId, item, 1));
+                        }
+                    }
+                    else {
+                        inserted.push(this.put(Number.MAX_SAFE_INTEGER, item, 0));
+                    }
                 }
             }
         }
+        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;
-    }
-    fill(data) {
+    };
+    BinaryTree.prototype.fill = function (data) {
         this.clear();
         return data.length === this.insertMany(data).length;
-    }
-    remove(id, ignoreCount) {
-        const nodes = this.getNodes(id, 'id', true);
-        let node = nodes[0];
+    };
+    BinaryTree.prototype.remove = function (id, ignoreCount) {
+        var nodes = this.getNodes(id, 'id', true);
+        var node = nodes[0];
         if (!node)
             node = undefined;
         else if (node.count > 1 && !ignoreCount) {
@@ -300,7 +391,7 @@ class BinaryTree {
             this.count--;
         }
         else if (node instanceof BinaryTreeNode) {
-            const [subSize, subCount] = this.getSubTreeSizeAndCount(node);
+            var _a = __read(this.getSubTreeSizeAndCount(node), 2), subSize = _a[0], subCount = _a[1];
             switch (node.familyPosition) {
                 case 0:
                     this.size -= subSize;
@@ -324,33 +415,34 @@ class BinaryTree {
             }
         }
         return [{ deleted: node, needBalanced: null }];
-    }
-    getDepth(node) {
-        let depth = 0;
+    };
+    BinaryTree.prototype.getDepth = function (node) {
+        var depth = 0;
         while (node.parent) {
             depth++;
             node = node.parent;
         }
         return depth;
-    }
-    getHeight(beginRoot) {
+    };
+    BinaryTree.prototype.getHeight = function (beginRoot) {
         var _a, _b, _c;
         beginRoot = beginRoot !== null && beginRoot !== void 0 ? beginRoot : this.root;
         if (!beginRoot)
             return -1;
         if (this._loopType === LoopType.recursive) {
-            const _getMaxHeight = (cur) => {
+            var _getMaxHeight_1 = function (cur) {
                 if (!cur)
                     return -1;
-                const leftHeight = _getMaxHeight(cur.left);
-                const rightHeight = _getMaxHeight(cur.right);
+                var leftHeight = _getMaxHeight_1(cur.left);
+                var rightHeight = _getMaxHeight_1(cur.right);
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            return _getMaxHeight(beginRoot);
+            return _getMaxHeight_1(beginRoot);
         }
         else {
-            const stack = [];
-            let node = beginRoot, last = null, depths = new Map();
+            var stack = [];
+            var node = beginRoot, last = null;
+            var depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -361,8 +453,8 @@ class BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let leftHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            let rightHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            var leftHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            var rightHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             depths.set(node, 1 + Math.max(leftHeight, rightHeight));
                             last = node;
                             node = null;
@@ -374,27 +466,28 @@ class BinaryTree {
             }
             return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
         }
-    }
-    getMinHeight(beginRoot) {
+    };
+    BinaryTree.prototype.getMinHeight = function (beginRoot) {
         var _a, _b, _c;
         beginRoot = beginRoot || this.root;
         if (!beginRoot)
             return -1;
         if (this._loopType === LoopType.recursive) {
-            const _getMinHeight = (cur) => {
+            var _getMinHeight_1 = function (cur) {
                 if (!cur)
                     return 0;
                 if (!cur.left && !cur.right)
                     return 0;
-                const leftMinHeight = _getMinHeight(cur.left);
-                const rightMinHeight = _getMinHeight(cur.right);
+                var leftMinHeight = _getMinHeight_1(cur.left);
+                var rightMinHeight = _getMinHeight_1(cur.right);
                 return Math.min(leftMinHeight, rightMinHeight) + 1;
             };
-            return _getMinHeight(beginRoot);
+            return _getMinHeight_1(beginRoot);
         }
         else {
-            const stack = [];
-            let node = beginRoot, last = null, depths = new Map();
+            var stack = [];
+            var node = beginRoot, last = null;
+            var depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -405,8 +498,8 @@ class BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let leftMinHeight = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            let rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            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;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -418,30 +511,31 @@ class BinaryTree {
             }
             return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
         }
-    }
-    isBalanced(beginRoot) {
+    };
+    BinaryTree.prototype.isBalanced = function (beginRoot) {
         return (this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot));
-    }
-    getNodes(nodeProperty, propertyName, onlyOne) {
+    };
+    BinaryTree.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
+        var _this = this;
         if (!this.root)
             return [];
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
-        const result = [];
+        var result = [];
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
-                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            var _traverse_1 = function (cur) {
+                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_1(cur.left);
+                cur.right && _traverse_1(cur.right);
             };
-            _traverse(this.root);
+            _traverse_1(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
@@ -451,181 +545,121 @@ class BinaryTree {
             }
         }
         return result;
-    }
-    has(nodeProperty, propertyName) {
+    };
+    BinaryTree.prototype.has = function (nodeProperty, propertyName) {
         return this.getNodes(nodeProperty, propertyName).length > 0;
-    }
-    get(nodeProperty, propertyName) {
+    };
+    BinaryTree.prototype.get = function (nodeProperty, propertyName) {
         var _a;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    getPathToRoot(node) {
-        const result = [];
+    };
+    BinaryTree.prototype.getPathToRoot = function (node) {
+        var result = [];
         while (node.parent) {
             result.unshift(node);
             node = node.parent;
         }
         result.unshift(node);
         return result;
-    }
-    _pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne) {
-        switch (propertyName) {
-            case 'id':
-                if (cur.id === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            case 'count':
-                if (cur.count === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            case 'val':
-                if (cur.val === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            default:
-                if (cur.id === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-        }
-    }
-    _accumulatedByPropertyName(node, nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
-        switch (nodeOrPropertyName) {
-            case 'id':
-                this._visitedId.push(node.id);
-                break;
-            case 'val':
-                this._visitedVal.push(node.val);
-                break;
-            case 'node':
-                this._visitedNode.push(node);
-                break;
-            case 'count':
-                this._visitedCount.push(node.count);
-                break;
-            default:
-                this._visitedId.push(node.id);
-                break;
-        }
-    }
-    _getResultByPropertyName(nodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
-        switch (nodeOrPropertyName) {
-            case 'id':
-                return this._visitedId;
-            case 'val':
-                return this._visitedVal;
-            case 'node':
-                return this._visitedNode;
-            case 'count':
-                return this._visitedCount;
-            default:
-                return this._visitedId;
-        }
-    }
-    getLeftMost(node) {
+    };
+    BinaryTree.prototype.getRoot = function () {
+        return this.root;
+    };
+    BinaryTree.prototype.getLeftMost = function (node) {
         node = node !== null && node !== void 0 ? node : this.root;
         if (!node)
             return node;
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
+            var _traverse_2 = function (cur) {
                 if (!cur.left)
                     return cur;
-                return _traverse(cur.left);
+                return _traverse_2(cur.left);
             };
-            return _traverse(node);
+            return _traverse_2(node);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, trampoline_1.trampoline)((cur) => {
+            var _traverse_3 = (0, trampoline_1.trampoline)(function (cur) {
                 if (!cur.left)
                     return cur;
-                return _traverse.cont(cur.left);
+                return _traverse_3.cont(cur.left);
             });
-            return _traverse(node);
+            return _traverse_3(node);
         }
-    }
-    getRightMost(node) {
+    };
+    BinaryTree.prototype.getRightMost = function (node) {
         node = node !== null && node !== void 0 ? node : this.root;
         if (!node)
             return node;
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
+            var _traverse_4 = function (cur) {
                 if (!cur.right)
                     return cur;
-                return _traverse(cur.right);
+                return _traverse_4(cur.right);
             };
-            return _traverse(node);
+            return _traverse_4(node);
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, trampoline_1.trampoline)((cur) => {
+            var _traverse_5 = (0, trampoline_1.trampoline)(function (cur) {
                 if (!cur.right)
                     return cur;
-                return _traverse.cont(cur.right);
+                return _traverse_5.cont(cur.right);
             });
-            return _traverse(node);
+            return _traverse_5(node);
         }
-    }
+    };
     // --- start additional methods ---
-    isBST(node) {
+    BinaryTree.prototype.isBST = function (node) {
         node = node !== null && node !== void 0 ? node : this.root;
         if (!node)
             return true;
         if (this._loopType === LoopType.recursive) {
-            const dfs = (cur, min, max) => {
+            var dfs_1 = function (cur, min, max) {
                 if (!cur)
                     return true;
                 if (cur.id <= min || cur.id >= max)
                     return false;
-                return dfs(cur.left, min, cur.id) && dfs(cur.right, cur.id, max);
+                return dfs_1(cur.left, min, cur.id) && dfs_1(cur.right, cur.id, max);
             };
-            return dfs(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            return dfs_1(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
         }
         else {
-            const stack = [];
-            let prev = Number.MIN_SAFE_INTEGER, curr = node;
+            var stack = [];
+            var prev = Number.MIN_SAFE_INTEGER, curr = node;
             while (curr || stack.length > 0) {
                 while (curr) {
                     stack.push(curr);
                     curr = curr.left;
                 }
                 curr = stack.pop();
-                if (prev >= curr.id)
+                if (!(curr) || prev >= curr.id)
                     return false;
                 prev = curr.id;
                 curr = curr.right;
             }
             return true;
         }
-    }
-    getSubTreeSizeAndCount(subTreeRoot) {
-        const res = [0, 0];
+    };
+    BinaryTree.prototype.getSubTreeSizeAndCount = function (subTreeRoot) {
+        var res = [0, 0];
         if (!subTreeRoot)
             return res;
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
+            var _traverse_6 = function (cur) {
                 res[0]++;
                 res[1] += cur.count;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_6(cur.left);
+                cur.right && _traverse_6(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_6(subTreeRoot);
             return res;
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 res[0]++;
                 res[1] += cur.count;
                 cur.right && stack.push(cur.right);
@@ -633,14 +667,14 @@ class BinaryTree {
             }
             return res;
         }
-    }
-    subTreeSum(subTreeRoot, propertyName) {
+    };
+    BinaryTree.prototype.subTreeSum = function (subTreeRoot, propertyName) {
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'val';
         if (!subTreeRoot)
             return 0;
-        let sum = 0;
-        const _sumByProperty = (cur) => {
-            let needSum;
+        var sum = 0;
+        var _sumByProperty = function (cur) {
+            var needSum;
             switch (propertyName) {
                 case 'id':
                     needSum = cur.id;
@@ -658,36 +692,37 @@ class BinaryTree {
             return needSum;
         };
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
+            var _traverse_7 = function (cur) {
                 sum += _sumByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_7(cur.left);
+                cur.right && _traverse_7(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_7(subTreeRoot);
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 sum += _sumByProperty(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return sum;
-    }
-    subTreeAdd(subTreeRoot, delta, propertyName) {
+    };
+    BinaryTree.prototype.subTreeAdd = function (subTreeRoot, delta, propertyName) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (!subTreeRoot)
             return false;
-        const _addByProperty = (cur) => {
+        var _addByProperty = function (cur) {
             switch (propertyName) {
                 case 'id':
                     cur.id += delta;
                     break;
                 case 'count':
                     cur.count += delta;
-                    this.count += delta;
+                    _this.count += delta;
                     break;
                 default:
                     cur.id += delta;
@@ -695,30 +730,30 @@ class BinaryTree {
             }
         };
         if (this._loopType === LoopType.recursive) {
-            const _traverse = (cur) => {
+            var _traverse_8 = function (cur) {
                 _addByProperty(cur);
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
+                cur.left && _traverse_8(cur.left);
+                cur.right && _traverse_8(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse_8(subTreeRoot);
         }
         else {
-            const stack = [subTreeRoot];
+            var stack = [subTreeRoot];
             while (stack.length > 0) {
-                const cur = stack.pop();
+                var cur = stack.pop();
                 _addByProperty(cur);
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
         return true;
-    }
-    BFS(nodeOrPropertyName) {
+    };
+    BinaryTree.prototype.BFS = function (nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
         this._resetResults();
-        const queue = [this.root];
+        var queue = [this.root];
         while (queue.length !== 0) {
-            const cur = queue.shift();
+            var cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 if ((cur === null || cur === void 0 ? void 0 : cur.left) !== null)
@@ -728,22 +763,23 @@ class BinaryTree {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-    DFS(pattern, nodeOrPropertyName) {
+    };
+    BinaryTree.prototype.DFS = function (pattern, nodeOrPropertyName) {
+        var _this = this;
         pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
         nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
         this._resetResults();
-        const _traverse = (node) => {
+        var _traverse = function (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)
@@ -754,13 +790,13 @@ class BinaryTree {
                         _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);
-    }
+    };
     /**
      * Time complexity is O(n)
      * Space complexity of Iterative DFS equals to recursive DFS which is O(n) because of the stack
@@ -768,16 +804,16 @@ class BinaryTree {
      * @param nodeOrPropertyName
      * @constructor
      */
-    DFSIterative(pattern, nodeOrPropertyName) {
+    BinaryTree.prototype.DFSIterative = function (pattern, nodeOrPropertyName) {
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         this._resetResults();
         if (!this.root)
             return this._getResultByPropertyName(nodeOrPropertyName);
         // 0: visit, 1: print
-        const stack = [{ opt: 0, node: this.root }];
+        var stack = [{ opt: 0, node: this.root }];
         while (stack.length > 0) {
-            const cur = stack.pop();
+            var cur = stack.pop();
             if (!cur || !cur.node)
                 continue;
             if (cur.opt === 1) {
@@ -809,16 +845,16 @@ class BinaryTree {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-    levelIterative(node, nodeOrPropertyName) {
+    };
+    BinaryTree.prototype.levelIterative = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         node = node || this.root;
         if (!node)
             return [];
         this._resetResults();
-        const queue = [node];
+        var queue = [node];
         while (queue.length > 0) {
-            const cur = queue.shift();
+            var cur = queue.shift();
             if (cur) {
                 this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 if (cur.left) {
@@ -830,14 +866,14 @@ class BinaryTree {
             }
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-    listLevels(node, nodeOrPropertyName) {
+    };
+    BinaryTree.prototype.listLevels = function (node, nodeOrPropertyName) {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         node = node || this.root;
         if (!node)
             return [];
-        const levelsNodes = [];
-        const collectByProperty = (node, level) => {
+        var levelsNodes = [];
+        var collectByProperty = function (node, level) {
             switch (nodeOrPropertyName) {
                 case 'id':
                     levelsNodes[level].push(node.id);
@@ -857,61 +893,64 @@ class BinaryTree {
             }
         };
         if (this._loopType === LoopType.recursive) {
-            const _recursive = (node, level) => {
+            var _recursive_1 = function (node, level) {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
                 collectByProperty(node, level);
                 if (node.left)
-                    _recursive(node.left, level + 1);
+                    _recursive_1(node.left, level + 1);
                 if (node.right)
-                    _recursive(node.right, level + 1);
+                    _recursive_1(node.right, level + 1);
             };
-            _recursive(node, 0);
+            _recursive_1(node, 0);
         }
         else {
-            const stack = [[node, 0]];
+            var stack = [[node, 0]];
             while (stack.length > 0) {
-                const head = stack.pop();
-                const [node, level] = head;
+                var head = stack.pop();
+                var _a = __read(head, 2), node_1 = _a[0], level = _a[1];
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
-                collectByProperty(node, level);
-                if (node.right)
-                    stack.push([node.right, level + 1]);
-                if (node.left)
-                    stack.push([node.left, level + 1]);
+                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]);
             }
         }
         return levelsNodes;
-    }
-    getPredecessor(node) {
+    };
+    BinaryTree.prototype.getPredecessor = function (node) {
         if (node.left) {
-            let predecessor = node.left;
-            while (predecessor.right && predecessor.right !== node) {
-                predecessor = predecessor.right;
+            var predecessor = node.left;
+            while (!(predecessor) || predecessor.right && predecessor.right !== node) {
+                if (predecessor) {
+                    predecessor = predecessor.right;
+                }
             }
             return predecessor;
         }
         else {
             return node;
         }
-    }
+    };
     /**
      * The time complexity of Morris traversal is O(n), it's may slower than others
      * The space complexity  Morris traversal is O(1) because no using stack
      * @param pattern
      * @param nodeOrPropertyName
      */
-    morris(pattern, nodeOrPropertyName) {
+    BinaryTree.prototype.morris = function (pattern, nodeOrPropertyName) {
+        var _this = this;
         if (this.root === null)
             return [];
         pattern = pattern || 'in';
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         this._resetResults();
-        let cur = this.root;
-        const _reverseEdge = (node) => {
-            let pre = null;
-            let next = null;
+        var cur = this.root;
+        var _reverseEdge = function (node) {
+            var pre = null;
+            var next = null;
             while (node) {
                 next = node.right;
                 node.right = pre;
@@ -920,11 +959,11 @@ class BinaryTree {
             }
             return pre;
         };
-        const _printEdge = (node) => {
-            const tail = _reverseEdge(node);
-            let cur = tail;
+        var _printEdge = function (node) {
+            var tail = _reverseEdge(node);
+            var cur = tail;
             while (cur) {
-                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                _this._accumulatedByPropertyName(cur, nodeOrPropertyName);
                 cur = cur.right;
             }
             _reverseEdge(tail);
@@ -933,7 +972,7 @@ class BinaryTree {
             case 'in':
                 while (cur) {
                     if (cur.left) {
-                        const predecessor = this.getPredecessor(cur);
+                        var predecessor = this.getPredecessor(cur);
                         if (!predecessor.right) {
                             predecessor.right = cur;
                             cur = cur.left;
@@ -950,7 +989,7 @@ class BinaryTree {
             case 'pre':
                 while (cur) {
                     if (cur.left) {
-                        const predecessor = this.getPredecessor(cur);
+                        var predecessor = this.getPredecessor(cur);
                         if (!predecessor.right) {
                             predecessor.right = cur;
                             this._accumulatedByPropertyName(cur, nodeOrPropertyName);
@@ -970,7 +1009,7 @@ class BinaryTree {
             case 'post':
                 while (cur) {
                     if (cur.left) {
-                        const predecessor = this.getPredecessor(cur);
+                        var predecessor = this.getPredecessor(cur);
                         if (predecessor.right === null) {
                             predecessor.right = cur;
                             cur = cur.left;
@@ -987,6 +1026,77 @@ class BinaryTree {
                 break;
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
-    }
-}
+    };
+    BinaryTree.prototype._resetResults = function () {
+        this._visitedId = [];
+        this._visitedVal = [];
+        this._visitedNode = [];
+        this._visitedCount = [];
+        this._visitedLeftSum = [];
+    };
+    BinaryTree.prototype._pushByPropertyNameStopOrNot = function (cur, result, nodeProperty, propertyName, onlyOne) {
+        switch (propertyName) {
+            case 'id':
+                if (cur.id === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            case 'count':
+                if (cur.count === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            case 'val':
+                if (cur.val === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            default:
+                if (cur.id === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+        }
+    };
+    BinaryTree.prototype._accumulatedByPropertyName = function (node, nodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+        switch (nodeOrPropertyName) {
+            case 'id':
+                this._visitedId.push(node.id);
+                break;
+            case 'val':
+                this._visitedVal.push(node.val);
+                break;
+            case 'node':
+                this._visitedNode.push(node);
+                break;
+            case 'count':
+                this._visitedCount.push(node.count);
+                break;
+            default:
+                this._visitedId.push(node.id);
+                break;
+        }
+    };
+    BinaryTree.prototype._getResultByPropertyName = function (nodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+        switch (nodeOrPropertyName) {
+            case 'id':
+                return this._visitedId;
+            case 'val':
+                return this._visitedVal;
+            case 'node':
+                return this._visitedNode;
+            case 'count':
+                return this._visitedCount;
+            default:
+                return this._visitedId;
+        }
+    };
+    return BinaryTree;
+}());
 exports.BinaryTree = BinaryTree;