data-structure-typed 1.35.1 → 1.36.1

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

@@ -1,876 +1,25 @@
 "use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractBinaryTree = exports.AbstractBinaryTreeNode = void 0;
-const utils_1 = require("../../utils");
-const types_1 = require("../../types");
 class AbstractBinaryTreeNode {
-    constructor(key, val) {
-        this.key = key;
+    /**
+     * The constructor function initializes a BinaryTreeNode object with a key and an optional value.
+     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It represents the value that will be
+     * stored in the binary tree node. If no value is provided, it will be set to undefined.
+     */
+    constructor(val) {
         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.LEFT;
-                }
-            }
-            else if (that.parent.right === that) {
-                if (that.left || that.right) {
-                    return types_1.FamilyPosition.ROOT_RIGHT;
-                }
-                else {
-                    return types_1.FamilyPosition.RIGHT;
-                }
-            }
-            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;
 class AbstractBinaryTree {
-    constructor(options) {
-        this._root = null;
-        this._size = 0;
-        this._loopType = types_1.LoopType.ITERATIVE;
-        this.visitedKey = [];
-        this.visitedVal = [];
-        this.visitedNode = [];
-        if (options !== undefined) {
-            const { loopType = types_1.LoopType.ITERATIVE } = options;
-            this._loopType = loopType;
-        }
-        this.clear();
-    }
-    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) {
-            destNode.key = srcNode.key;
-            destNode.val = srcNode.val;
-            srcNode.key = tempNode.key;
-            srcNode.val = tempNode.val;
-        }
-        return destNode;
-    }
-    clear() {
-        this._root = null;
-        this._size = 0;
-        this._clearResults();
-    }
-    isEmpty() {
-        return this.size === 0;
-    }
-    add(keyOrNode, val) {
-        const _bfs = (root, newNode) => {
-            const queue = [root];
-            while (queue.length > 0) {
-                const cur = queue.shift();
-                if (cur) {
-                    if (newNode && cur.key === newNode.key)
-                        return;
-                    const inserted = this._addTo(newNode, 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, needInsert;
-        if (keyOrNode === null) {
-            needInsert = null;
-        }
-        else if (typeof keyOrNode === 'number') {
-            needInsert = this.createNode(keyOrNode, val);
-        }
-        else if (keyOrNode instanceof AbstractBinaryTreeNode) {
-            needInsert = keyOrNode;
-        }
-        else {
-            return;
-        }
-        const existNode = keyOrNode ? this.get(keyOrNode, 'key') : undefined;
-        if (this.root) {
-            if (existNode) {
-                existNode.val = val;
-                inserted = existNode;
-            }
-            else {
-                inserted = _bfs(this.root, needInsert);
-            }
-        }
-        else {
-            this._setRoot(needInsert);
-            if (needInsert !== null) {
-                this._setSize(1);
-            }
-            else {
-                this._setSize(0);
-            }
-            inserted = this.root;
-        }
-        return inserted;
-    }
-    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 (keyOrNode === null) {
-                inserted.push(this.add(null));
-                continue;
-            }
-            const val = data === null || data === void 0 ? void 0 : data[i];
-            inserted.push(this.add(keyOrNode, val));
-        }
-        return inserted;
-    }
-    refill(keysOrNodes, data) {
-        this.clear();
-        return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
-    }
-    remove(nodeOrKey) {
-        const bstDeletedResult = [];
-        if (!this.root)
-            return bstDeletedResult;
-        const curr = typeof nodeOrKey === 'number' ? this.get(nodeOrKey) : nodeOrKey;
-        if (!curr)
-            return bstDeletedResult;
-        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 {
-                const { familyPosition: fp } = curr;
-                if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
-                    parent.left = curr.right;
-                }
-                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
-                    parent.right = curr.right;
-                }
-                needBalanced = parent;
-            }
-        }
-        else {
-            const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : null;
-            if (leftSubTreeRightMost) {
-                const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
-                if (parentOfLeftSubTreeMax) {
-                    if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
-                        parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-                    else
-                        parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
-                    needBalanced = parentOfLeftSubTreeMax;
-                }
-            }
-        }
-        this._setSize(this.size - 1);
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
-        return bstDeletedResult;
-    }
-    getDepth(beginRoot = this.root) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
-        let depth = 0;
-        while (beginRoot === null || beginRoot === void 0 ? void 0 : beginRoot.parent) {
-            depth++;
-            beginRoot = beginRoot.parent;
-        }
-        return depth;
-    }
-    getHeight(beginRoot = this.root) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
-        if (!beginRoot)
-            return -1;
-        if (this._loopType === types_1.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 {
-            if (!beginRoot) {
-                return -1;
-            }
-            const stack = [{ node: beginRoot, depth: 0 }];
-            let maxHeight = 0;
-            while (stack.length > 0) {
-                const { node, depth } = stack.pop();
-                if (node.left) {
-                    stack.push({ node: node.left, depth: depth + 1 });
-                }
-                if (node.right) {
-                    stack.push({ node: node.right, depth: depth + 1 });
-                }
-                maxHeight = Math.max(maxHeight, depth);
-            }
-            return maxHeight;
-        }
-    }
-    getMinHeight(beginRoot = this.root) {
-        var _a, _b, _c;
-        if (!beginRoot)
-            return -1;
-        if (this._loopType === types_1.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;
-            const 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) {
-                            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;
-                        }
-                    }
-                    else
-                        node = node.right;
-                }
-            }
-            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
-        }
-    }
-    isPerfectlyBalanced(beginRoot = this.root) {
-        return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
-    }
-    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
-        if (!this.root)
-            return [];
-        const result = [];
-        if (this.loopType === types_1.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 = 'key') {
-        return this.getNodes(nodeProperty, propertyName).length > 0;
-    }
-    get(nodeProperty, propertyName = 'key') {
-        var _a;
-        return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    getPathToRoot(node, isReverse = true) {
-        const result = [];
-        while (node.parent) {
-            result.push(node);
-            node = node.parent;
-        }
-        result.push(node);
-        return isReverse ? result.reverse() : result;
-    }
-    getLeftMost(beginRoot = this.root) {
-        if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
-        if (!beginRoot)
-            return beginRoot;
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                if (!cur.left)
-                    return cur;
-                return _traverse(cur.left);
-            };
-            return _traverse(beginRoot);
-        }
-        else {
-            const _traverse = (0, utils_1.trampoline)((cur) => {
-                if (!cur.left)
-                    return cur;
-                return _traverse.cont(cur.left);
-            });
-            return _traverse(beginRoot);
-        }
-    }
-    getRightMost(beginRoot = this.root) {
-        if (!beginRoot)
-            return beginRoot;
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                if (!cur.right)
-                    return cur;
-                return _traverse(cur.right);
-            };
-            return _traverse(beginRoot);
-        }
-        else {
-            const _traverse = (0, utils_1.trampoline)((cur) => {
-                if (!cur.right)
-                    return cur;
-                return _traverse.cont(cur.right);
-            });
-            return _traverse(beginRoot);
-        }
-    }
-    isSubtreeBST(node) {
-        if (!node)
-            return true;
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
-            const dfs = (cur, min, max) => {
-                if (!cur)
-                    return true;
-                if (cur.key <= min || cur.key >= max)
-                    return false;
-                return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, 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 (!curr || prev >= curr.key)
-                    return false;
-                prev = curr.key;
-                curr = curr.right;
-            }
-            return true;
-        }
-    }
-    isBST() {
-        return this.isSubtreeBST(this.root);
-    }
-    getSubTreeSize(subTreeRoot) {
-        let size = 0;
-        if (!subTreeRoot)
-            return size;
-        if (this._loopType === types_1.LoopType.RECURSIVE) {
-            const _traverse = (cur) => {
-                size++;
-                cur.left && _traverse(cur.left);
-                cur.right && _traverse(cur.right);
-            };
-            _traverse(subTreeRoot);
-            return size;
-        }
-        else {
-            const stack = [subTreeRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                size++;
-                cur.right && stack.push(cur.right);
-                cur.left && stack.push(cur.left);
-            }
-            return size;
-        }
-    }
-    subTreeSum(subTreeRoot, propertyName = 'key') {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return 0;
-        let sum = 0;
-        const _sumByProperty = (cur) => {
-            let needSum;
-            switch (propertyName) {
-                case 'key':
-                    needSum = cur.key;
-                    break;
-                case 'val':
-                    needSum = typeof cur.val === 'number' ? cur.val : 0;
-                    break;
-                default:
-                    needSum = cur.key;
-                    break;
-            }
-            return needSum;
-        };
-        if (this._loopType === types_1.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 = 'key') {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return false;
-        const _addByProperty = (cur) => {
-            switch (propertyName) {
-                case 'key':
-                    cur.key += delta;
-                    break;
-                default:
-                    cur.key += delta;
-                    break;
-            }
-        };
-        if (this._loopType === types_1.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 = 'key') {
-        this._clearResults();
-        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 = 'in', nodeOrPropertyName = 'key') {
-        this._clearResults();
-        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);
-    }
-    dfsIterative(pattern = 'in', nodeOrPropertyName = 'key') {
-        this._clearResults();
-        if (!this.root)
-            return this._getResultByPropertyName(nodeOrPropertyName);
-        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 = this.root, nodeOrPropertyName = 'key') {
-        if (!node)
-            return [];
-        this._clearResults();
-        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 = this.root, nodeOrPropertyName = 'key') {
-        if (!node)
-            return [];
-        const levelsNodes = [];
-        const collectByProperty = (node, level) => {
-            switch (nodeOrPropertyName) {
-                case 'key':
-                    levelsNodes[level].push(node.key);
-                    break;
-                case 'val':
-                    levelsNodes[level].push(node.val);
-                    break;
-                case 'node':
-                    levelsNodes[level].push(node);
-                    break;
-                default:
-                    levelsNodes[level].push(node.key);
-                    break;
-            }
-        };
-        if (this.loopType === types_1.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 || (predecessor.right && predecessor.right !== node)) {
-                if (predecessor) {
-                    predecessor = predecessor.right;
-                }
-            }
-            return predecessor;
-        }
-        else {
-            return node;
-        }
-    }
-    morris(pattern = 'in', nodeOrPropertyName = 'key') {
-        if (this.root === null)
-            return [];
-        this._clearResults();
-        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);
-    }
-    _addTo(newNode, parent) {
-        if (parent) {
-            if (parent.left === undefined) {
-                parent.left = newNode;
-                if (newNode) {
-                    this._setSize(this.size + 1);
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                parent.right = newNode;
-                if (newNode) {
-                    this._setSize(this.size + 1);
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    }
-    _setLoopType(value) {
-        this._loopType = value;
-    }
-    _setRoot(v) {
-        if (v) {
-            v.parent = undefined;
-        }
-        this._root = v;
-    }
-    _setSize(v) {
-        this._size = v;
-    }
-    _clearResults() {
-        this.visitedKey = [];
-        this.visitedVal = [];
-        this.visitedNode = [];
-    }
-    _pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName = 'key', onlyOne = false) {
-        switch (propertyName) {
-            case 'key':
-                if (cur.key === nodeProperty) {
-                    result.push(cur);
-                    return onlyOne;
-                }
-                break;
-            case 'val':
-                if (cur.val === nodeProperty) {
-                    result.push(cur);
-                    return onlyOne;
-                }
-                break;
-            default:
-                if (cur.key === nodeProperty) {
-                    result.push(cur);
-                    return onlyOne;
-                }
-                break;
-        }
-    }
-    _accumulatedByPropertyName(node, nodeOrPropertyName = 'key') {
-        switch (nodeOrPropertyName) {
-            case 'key':
-                this.visitedKey.push(node.key);
-                break;
-            case 'val':
-                this.visitedVal.push(node.val);
-                break;
-            case 'node':
-                this.visitedNode.push(node);
-                break;
-            default:
-                this.visitedKey.push(node.key);
-                break;
-        }
-    }
-    _getResultByPropertyName(nodeOrPropertyName = 'key') {
-        switch (nodeOrPropertyName) {
-            case 'key':
-                return this.visitedKey;
-            case 'val':
-                return this.visitedVal;
-            case 'node':
-                return this.visitedNode;
-            default:
-                return this.visitedKey;
-        }
-    }
 }
 exports.AbstractBinaryTree = AbstractBinaryTree;
 //# sourceMappingURL=abstract-binary-tree.js.map