data-structure-typed 0.8.6

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

@@ -0,0 +1,992 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryTree = exports.BinaryTreeNode = exports.LoopType = exports.FamilyPosition = void 0;
+const trampoline_1 = require("../trampoline");
+var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition[FamilyPosition["root"] = 0] = "root";
+    FamilyPosition[FamilyPosition["left"] = 1] = "left";
+    FamilyPosition[FamilyPosition["right"] = 2] = "right";
+})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
+var LoopType;
+(function (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;
+        this._familyPosition = FamilyPosition.root;
+        this._count = 1;
+        this._height = 0;
+        this._id = id;
+        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);
+        tempNode.val = val;
+        tempNode.count = count;
+        tempNode.height = height;
+        swapNode.id = this.id;
+        swapNode.val = this.val;
+        swapNode.count = this.count;
+        swapNode.height = this.height;
+        this.id = tempNode.id;
+        this.val = tempNode.val;
+        this.count = tempNode.count;
+        this.height = tempNode.height;
+        return swapNode;
+    }
+    clone() {
+        return new BinaryTreeNode(this.id, this.val, this.count);
+    }
+}
+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() {
+        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 = [];
+        if (options !== undefined) {
+            const { loopType = LoopType.iterative, autoIncrementId = false, isDuplicatedVal = false } = options;
+            this._isDuplicatedVal = isDuplicatedVal;
+            this._autoIncrementId = autoIncrementId;
+            this._loopType = loopType;
+        }
+    }
+    createNode(id, val, count) {
+        return val !== null ? new BinaryTreeNode(id, val, count) : null;
+    }
+    clear() {
+        this.root = null;
+        this.size = 0;
+        this.count = 0;
+        this._maxId = -1;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    insertTo({ newNode, parent }) {
+        var _a, _b;
+        if (parent) {
+            if (parent.left === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.left;
+                }
+                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;
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.right;
+                }
+                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;
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    }
+    put(id, val, count) {
+        count = count !== null && count !== void 0 ? count : 1;
+        const _bfs = (root, newNode) => {
+            const queue = [root];
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    const inserted = this.insertTo({ newNode, parent: cur });
+                    if (inserted !== undefined)
+                        return inserted;
+                    if (cur.left)
+                        queue.push(cur.left);
+                    if (cur.right)
+                        queue.push(cur.right);
+                }
+                else
+                    return;
+            }
+            return;
+        };
+        let inserted;
+        const needInsert = val !== null ? new BinaryTreeNode(id, val, count) : null;
+        const existNode = val !== null ? this.get(id, 'id') : null;
+        if (this.root) {
+            if (existNode) {
+                existNode.count += count;
+                existNode.val = val;
+                if (needInsert !== null) {
+                    this.count += count;
+                    inserted = existNode;
+                }
+            }
+            else {
+                inserted = _bfs(this.root, needInsert);
+            }
+        }
+        else {
+            this.root = val !== null ? new BinaryTreeNode(id, val, count) : null;
+            if (needInsert !== null) {
+                this.size = 1;
+                this.count = count;
+            }
+            inserted = this.root;
+        }
+        return inserted;
+    }
+    insertMany(data) {
+        var _a;
+        const inserted = [];
+        const 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);
+                    }
+                }
+                else {
+                    inserted.push(this.put(item, item, 1));
+                }
+            }
+            else {
+                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));
+                }
+            }
+        }
+        return inserted;
+    }
+    fill(data) {
+        this.clear();
+        return data.length === this.insertMany(data).length;
+    }
+    remove(id, ignoreCount) {
+        const nodes = this.getNodes(id, 'id', true);
+        let node = nodes[0];
+        if (!node)
+            node = undefined;
+        else if (node.count > 1 && !ignoreCount) {
+            node.count--;
+            this.count--;
+        }
+        else if (node instanceof BinaryTreeNode) {
+            const [subSize, subCount] = this.getSubTreeSizeAndCount(node);
+            switch (node.familyPosition) {
+                case 0:
+                    this.size -= subSize;
+                    this.count -= subCount;
+                    node = undefined;
+                    break;
+                case 1:
+                    if (node.parent) {
+                        this.size -= subSize;
+                        this.count -= subCount;
+                        node.parent.left = null;
+                    }
+                    break;
+                case 2:
+                    if (node.parent) {
+                        this.size -= subSize;
+                        this.count -= subCount;
+                        node.parent.right = null;
+                    }
+                    break;
+            }
+        }
+        return [{ deleted: node, needBalanced: null }];
+    }
+    getDepth(node) {
+        let depth = 0;
+        while (node.parent) {
+            depth++;
+            node = node.parent;
+        }
+        return depth;
+    }
+    getHeight(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) => {
+                if (!cur)
+                    return -1;
+                const leftHeight = _getMaxHeight(cur.left);
+                const rightHeight = _getMaxHeight(cur.right);
+                return Math.max(leftHeight, rightHeight) + 1;
+            };
+            return _getMaxHeight(beginRoot);
+        }
+        else {
+            const stack = [];
+            let node = beginRoot, last = null, depths = new Map();
+            while (stack.length > 0 || node) {
+                if (node) {
+                    stack.push(node);
+                    node = node.left;
+                }
+                else {
+                    node = stack[stack.length - 1];
+                    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;
+                            depths.set(node, 1 + Math.max(leftHeight, rightHeight));
+                            last = node;
+                            node = null;
+                        }
+                    }
+                    else
+                        node = node.right;
+                }
+            }
+            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+        }
+    }
+    getMinHeight(beginRoot) {
+        var _a, _b, _c;
+        beginRoot = beginRoot || this.root;
+        if (!beginRoot)
+            return -1;
+        if (this._loopType === LoopType.recursive) {
+            const _getMinHeight = (cur) => {
+                if (!cur)
+                    return 0;
+                if (!cur.left && !cur.right)
+                    return 0;
+                const leftMinHeight = _getMinHeight(cur.left);
+                const rightMinHeight = _getMinHeight(cur.right);
+                return Math.min(leftMinHeight, rightMinHeight) + 1;
+            };
+            return _getMinHeight(beginRoot);
+        }
+        else {
+            const stack = [];
+            let node = beginRoot, last = null, depths = new Map();
+            while (stack.length > 0 || node) {
+                if (node) {
+                    stack.push(node);
+                    node = node.left;
+                }
+                else {
+                    node = stack[stack.length - 1];
+                    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;
+                            depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
+                            last = node;
+                            node = null;
+                        }
+                    }
+                    else
+                        node = node.right;
+                }
+            }
+            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+        }
+    }
+    isBalanced(beginRoot) {
+        return (this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot));
+    }
+    getNodes(nodeProperty, propertyName, onlyOne) {
+        if (!this.root)
+            return [];
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        const result = [];
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (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);
+            };
+            _traverse(this.root);
+        }
+        else {
+            const queue = [this.root];
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                if (cur) {
+                    if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+                        return result;
+                    cur.left && queue.push(cur.left);
+                    cur.right && queue.push(cur.right);
+                }
+            }
+        }
+        return result;
+    }
+    has(nodeProperty, propertyName) {
+        return this.getNodes(nodeProperty, propertyName).length > 0;
+    }
+    get(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 = [];
+        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) {
+        node = node !== null && node !== void 0 ? node : this.root;
+        if (!node)
+            return node;
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (cur) => {
+                if (!cur.left)
+                    return cur;
+                return _traverse(cur.left);
+            };
+            return _traverse(node);
+        }
+        else {
+            // Indirect implementation of iteration using tail recursion optimization
+            const _traverse = (0, trampoline_1.trampoline)((cur) => {
+                if (!cur.left)
+                    return cur;
+                return _traverse.cont(cur.left);
+            });
+            return _traverse(node);
+        }
+    }
+    getRightMost(node) {
+        node = node !== null && node !== void 0 ? node : this.root;
+        if (!node)
+            return node;
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (cur) => {
+                if (!cur.right)
+                    return cur;
+                return _traverse(cur.right);
+            };
+            return _traverse(node);
+        }
+        else {
+            // Indirect implementation of iteration using tail recursion optimization
+            const _traverse = (0, trampoline_1.trampoline)((cur) => {
+                if (!cur.right)
+                    return cur;
+                return _traverse.cont(cur.right);
+            });
+            return _traverse(node);
+        }
+    }
+    // --- start additional methods ---
+    isBST(node) {
+        node = node !== null && node !== void 0 ? node : this.root;
+        if (!node)
+            return true;
+        if (this._loopType === LoopType.recursive) {
+            const dfs = (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(node, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+        }
+        else {
+            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 (prev >= curr.id)
+                    return false;
+                prev = curr.id;
+                curr = curr.right;
+            }
+            return true;
+        }
+    }
+    getSubTreeSizeAndCount(subTreeRoot) {
+        const res = [0, 0];
+        if (!subTreeRoot)
+            return res;
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (cur) => {
+                res[0]++;
+                res[1] += cur.count;
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
+            };
+            _traverse(subTreeRoot);
+            return res;
+        }
+        else {
+            const stack = [subTreeRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                res[0]++;
+                res[1] += cur.count;
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+            return res;
+        }
+    }
+    subTreeSum(subTreeRoot, propertyName) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'val';
+        if (!subTreeRoot)
+            return 0;
+        let sum = 0;
+        const _sumByProperty = (cur) => {
+            let needSum;
+            switch (propertyName) {
+                case 'id':
+                    needSum = cur.id;
+                    break;
+                case 'count':
+                    needSum = cur.count;
+                    break;
+                case 'val':
+                    needSum = typeof cur.val === 'number' ? cur.val : 0;
+                    break;
+                default:
+                    needSum = cur.id;
+                    break;
+            }
+            return needSum;
+        };
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (cur) => {
+                sum += _sumByProperty(cur);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
+            };
+            _traverse(subTreeRoot);
+        }
+        else {
+            const stack = [subTreeRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                sum += _sumByProperty(cur);
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+        }
+        return sum;
+    }
+    subTreeAdd(subTreeRoot, delta, propertyName) {
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (!subTreeRoot)
+            return false;
+        const _addByProperty = (cur) => {
+            switch (propertyName) {
+                case 'id':
+                    cur.id += delta;
+                    break;
+                case 'count':
+                    cur.count += delta;
+                    this.count += delta;
+                    break;
+                default:
+                    cur.id += delta;
+                    break;
+            }
+        };
+        if (this._loopType === LoopType.recursive) {
+            const _traverse = (cur) => {
+                _addByProperty(cur);
+                cur.left && _traverse(cur.left);
+                cur.right && _traverse(cur.right);
+            };
+            _traverse(subTreeRoot);
+        }
+        else {
+            const stack = [subTreeRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
+                _addByProperty(cur);
+                cur.right && stack.push(cur.right);
+                cur.left && stack.push(cur.left);
+            }
+        }
+        return true;
+    }
+    BFS(nodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+        this._resetResults();
+        const queue = [this.root];
+        while (queue.length !== 0) {
+            const cur = queue.shift();
+            if (cur) {
+                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                if ((cur === null || cur === void 0 ? void 0 : cur.left) !== null)
+                    queue.push(cur.left);
+                if ((cur === null || cur === void 0 ? void 0 : cur.right) !== null)
+                    queue.push(cur.right);
+            }
+        }
+        return this._getResultByPropertyName(nodeOrPropertyName);
+    }
+    DFS(pattern, nodeOrPropertyName) {
+        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
+        nodeOrPropertyName = nodeOrPropertyName !== null && nodeOrPropertyName !== void 0 ? nodeOrPropertyName : 'id';
+        this._resetResults();
+        const _traverse = (node) => {
+            switch (pattern) {
+                case 'in':
+                    if (node.left)
+                        _traverse(node.left);
+                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                    if (node.right)
+                        _traverse(node.right);
+                    break;
+                case 'pre':
+                    this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                    if (node.left)
+                        _traverse(node.left);
+                    if (node.right)
+                        _traverse(node.right);
+                    break;
+                case 'post':
+                    if (node.left)
+                        _traverse(node.left);
+                    if (node.right)
+                        _traverse(node.right);
+                    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
+     * @param pattern
+     * @param nodeOrPropertyName
+     * @constructor
+     */
+    DFSIterative(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 }];
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            if (!cur || !cur.node)
+                continue;
+            if (cur.opt === 1) {
+                this._accumulatedByPropertyName(cur.node, nodeOrPropertyName);
+            }
+            else {
+                switch (pattern) {
+                    case 'in':
+                        stack.push({ opt: 0, node: cur.node.right });
+                        stack.push({ opt: 1, node: cur.node });
+                        stack.push({ opt: 0, node: cur.node.left });
+                        break;
+                    case 'pre':
+                        stack.push({ opt: 0, node: cur.node.right });
+                        stack.push({ opt: 0, node: cur.node.left });
+                        stack.push({ opt: 1, node: cur.node });
+                        break;
+                    case 'post':
+                        stack.push({ opt: 1, node: cur.node });
+                        stack.push({ opt: 0, node: cur.node.right });
+                        stack.push({ opt: 0, node: cur.node.left });
+                        break;
+                    default:
+                        stack.push({ opt: 0, node: cur.node.right });
+                        stack.push({ opt: 1, node: cur.node });
+                        stack.push({ opt: 0, node: cur.node.left });
+                        break;
+                }
+            }
+        }
+        return this._getResultByPropertyName(nodeOrPropertyName);
+    }
+    levelIterative(node, nodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName || 'id';
+        node = node || this.root;
+        if (!node)
+            return [];
+        this._resetResults();
+        const queue = [node];
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            if (cur) {
+                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                if (cur.left) {
+                    queue.push(cur.left);
+                }
+                if (cur.right) {
+                    queue.push(cur.right);
+                }
+            }
+        }
+        return this._getResultByPropertyName(nodeOrPropertyName);
+    }
+    listLevels(node, nodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName || 'id';
+        node = node || this.root;
+        if (!node)
+            return [];
+        const levelsNodes = [];
+        const collectByProperty = (node, level) => {
+            switch (nodeOrPropertyName) {
+                case 'id':
+                    levelsNodes[level].push(node.id);
+                    break;
+                case 'val':
+                    levelsNodes[level].push(node.val);
+                    break;
+                case 'node':
+                    levelsNodes[level].push(node);
+                    break;
+                case 'count':
+                    levelsNodes[level].push(node.count);
+                    break;
+                default:
+                    levelsNodes[level].push(node.id);
+                    break;
+            }
+        };
+        if (this._loopType === LoopType.recursive) {
+            const _recursive = (node, level) => {
+                if (!levelsNodes[level])
+                    levelsNodes[level] = [];
+                collectByProperty(node, level);
+                if (node.left)
+                    _recursive(node.left, level + 1);
+                if (node.right)
+                    _recursive(node.right, level + 1);
+            };
+            _recursive(node, 0);
+        }
+        else {
+            const stack = [[node, 0]];
+            while (stack.length > 0) {
+                const head = stack.pop();
+                const [node, level] = head;
+                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]);
+            }
+        }
+        return levelsNodes;
+    }
+    getPredecessor(node) {
+        if (node.left) {
+            let predecessor = node.left;
+            while (predecessor.right && predecessor.right !== node) {
+                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) {
+        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;
+            while (node) {
+                next = node.right;
+                node.right = pre;
+                pre = node;
+                node = next;
+            }
+            return pre;
+        };
+        const _printEdge = (node) => {
+            const tail = _reverseEdge(node);
+            let cur = tail;
+            while (cur) {
+                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                cur = cur.right;
+            }
+            _reverseEdge(tail);
+        };
+        switch (pattern) {
+            case 'in':
+                while (cur) {
+                    if (cur.left) {
+                        const predecessor = this.getPredecessor(cur);
+                        if (!predecessor.right) {
+                            predecessor.right = cur;
+                            cur = cur.left;
+                            continue;
+                        }
+                        else {
+                            predecessor.right = null;
+                        }
+                    }
+                    this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                    cur = cur.right;
+                }
+                break;
+            case 'pre':
+                while (cur) {
+                    if (cur.left) {
+                        const predecessor = this.getPredecessor(cur);
+                        if (!predecessor.right) {
+                            predecessor.right = cur;
+                            this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                            cur = cur.left;
+                            continue;
+                        }
+                        else {
+                            predecessor.right = null;
+                        }
+                    }
+                    else {
+                        this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                    }
+                    cur = cur.right;
+                }
+                break;
+            case 'post':
+                while (cur) {
+                    if (cur.left) {
+                        const predecessor = this.getPredecessor(cur);
+                        if (predecessor.right === null) {
+                            predecessor.right = cur;
+                            cur = cur.left;
+                            continue;
+                        }
+                        else {
+                            predecessor.right = null;
+                            _printEdge(cur.left);
+                        }
+                    }
+                    cur = cur.right;
+                }
+                _printEdge(this.root);
+                break;
+        }
+        return this._getResultByPropertyName(nodeOrPropertyName);
+    }
+}
+exports.BinaryTree = BinaryTree;