data-structure-typed 1.37.1 → 1.37.3

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { FamilyPosition, LoopType } from '../../types';
+import { FamilyPosition, IterationType } from '../../types';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
 export class BinaryTreeNode {
@@ -86,13 +86,11 @@ export class BinaryTree {
         // TODO placeholder node may need redesigned
         this._root = null;
         this._size = 0;
-        this._loopType = LoopType.ITERATIVE;
-        this.visitedKey = [];
-        this.visitedVal = [];
-        this.visitedNode = [];
+        this._loopType = IterationType.ITERATIVE;
+        this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
-            const { loopType = LoopType.ITERATIVE } = options;
-            this._loopType = loopType;
+            const { iterationType = IterationType.ITERATIVE } = options;
+            this._loopType = iterationType;
         }
     }
     /**
@@ -112,10 +110,10 @@ export class BinaryTree {
     get size() {
         return this._size;
     }
-    get loopType() {
+    get iterationType() {
         return this._loopType;
     }
-    set loopType(v) {
+    set iterationType(v) {
         this._loopType = v;
     }
     /**
@@ -142,7 +140,6 @@ export class BinaryTree {
     clear() {
         this._root = null;
         this._size = 0;
-        this._clearResults();
     }
     /**
      * The function checks if the size of an object is equal to zero and returns a boolean value.
@@ -198,7 +195,7 @@ export class BinaryTree {
         else {
             return;
         }
-        const existNode = keyOrNode ? this.get(keyOrNode, 'key') : undefined;
+        const existNode = keyOrNode ? this.get(keyOrNode, this._defaultCallbackByKey) : undefined;
         if (this.root) {
             if (existNode) {
                 existNode.val = val;
@@ -319,9 +316,9 @@ export class BinaryTree {
      */
     getDepth(distNode, beginRoot = this.root) {
         if (typeof distNode === 'number')
-            distNode = this.get(distNode, 'key');
+            distNode = this.get(distNode);
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
+            beginRoot = this.get(beginRoot);
         let depth = 0;
         while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
             if (distNode === beginRoot) {
@@ -337,14 +334,15 @@ export class BinaryTree {
      * @param {N | BinaryTreeNodeKey | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
      * generic type representing a node in a binary tree), `BinaryTreeNodeKey` (a type representing the ID of a binary tree
      * node), or `null`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root) {
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
+            beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return -1;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
@@ -379,13 +377,14 @@ export class BinaryTree {
      * @param {N | null} [beginRoot] - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It
      * represents the starting node from which to calculate the minimum height of a binary tree. If no value is provided
      * for `beginRoot`, the `this.root` property is used as the default value.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns The function `getMinHeight` returns the minimum height of the binary tree.
      */
-    getMinHeight(beginRoot = this.root) {
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b, _c;
         if (!beginRoot)
             return -1;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _getMinHeight = (cur) => {
                 if (!cur)
                     return 0;
@@ -437,92 +436,104 @@ export class BinaryTree {
     }
     /**
      * The function `getNodes` returns an array of nodes that match a given property name and value in a binary tree.
+     * @param callback
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to use when searching for nodes. If not provided, it defaults to 'key'.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or `propertyName`. If `onlyOne` is set to `true`, the
      * function will stop traversing the tree and return the first matching node. If `only
+     * @param beginRoot
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
-        if (!this.root)
+    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if (!beginRoot)
             return [];
-        const result = [];
-        if (this.loopType === LoopType.RECURSIVE) {
+        const ans = [];
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
-                    return;
+                if (callback(cur) === nodeProperty) {
+                    ans.push(cur);
+                    if (onlyOne)
+                        return;
+                }
                 if (!cur.left && !cur.right)
                     return;
                 cur.left && _traverse(cur.left);
                 cur.right && _traverse(cur.right);
             };
-            _traverse(this.root);
+            _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([this.root]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
-                        return result;
+                    if (callback(cur) === nodeProperty) {
+                        ans.push(cur);
+                        if (onlyOne)
+                            return ans;
+                    }
                     cur.left && queue.push(cur.left);
                     cur.right && queue.push(cur.right);
                 }
             }
         }
-        return result;
+        return ans;
     }
     /**
      * The function checks if a binary tree node has a specific property.
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or `N`.
      * It represents the property of the binary tree node that you want to check.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the name of the property to be checked in the nodes. If not provided, it defaults to 'key'.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It represents the root node of a tree or null if the tree is empty.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns a boolean value.
      */
-    has(nodeProperty, propertyName = 'key') {
+    has(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         // TODO may support finding node by value equal
-        return this.getNodes(nodeProperty, propertyName).length > 0;
+        return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType).length > 0;
     }
     /**
      * The function returns the first node that matches the given property name and value, or null if no matching node is
      * found.
+     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or `N`.
      * It represents the property of the binary tree node that you want to search for.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name to be used for searching the binary tree nodes. If this parameter is not provided, the
      * default value is set to `'key'`.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It represents the root node of a tree or null if the tree is empty.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop used to traverse the binary tree.
      * @returns either the value of the specified property of the node, or the node itself if no property name is provided.
      * If no matching node is found, it returns null.
      */
-    get(nodeProperty, propertyName = 'key') {
+    get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         // TODO may support finding node by value equal
-        return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * The function `getPathToRoot` returns an array of nodes representing the path from a given node to the root node, with
      * an option to reverse the order of the nodes.
-     * @param {N} node - The `node` parameter represents a node in a tree structure. It is of type `N`, which could be any
      * type that represents a node in your specific implementation.
+     * @param beginRoot   - The `beginRoot` parameter is of type `N` and represents the starting node from which you want to
      * @param {boolean} [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the resulting
      * path should be reversed or not. If `isReverse` is set to `true`, the path will be reversed before returning it. If
      * `isReverse` is set to `false` or not provided, the path will
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
-    getPathToRoot(node, isReverse = true) {
+    getPathToRoot(beginRoot, isReverse = true) {
         // TODO to support get path through passing key
         const result = [];
-        while (node.parent) {
+        while (beginRoot.parent) {
             // Array.push + Array.reverse is more efficient than Array.unshift
             // TODO may consider using Deque, so far this is not the performance bottleneck
-            result.push(node);
-            node = node.parent;
+            result.push(beginRoot);
+            beginRoot = beginRoot.parent;
         }
-        result.push(node);
+        result.push(beginRoot);
         return isReverse ? result.reverse() : result;
     }
     /**
@@ -531,17 +542,18 @@ export class BinaryTree {
      * @param {N | BinaryTreeNodeKey | null} [beginRoot] - The `beginRoot` parameter is optional and can be of type `N` (a
      * generic type representing a node in a binary tree), `BinaryTreeNodeKey` (a type representing the ID of a binary tree
      * node), or `null`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop used to traverse the binary tree.
      * @returns The function `getLeftMost` returns the leftmost node in a binary tree. If the `beginRoot` parameter is
      * provided, it starts the traversal from that node. If `beginRoot` is not provided or is `null`, it starts the traversal
      * from the root of the binary tree. The function returns the leftmost node found during the traversal. If no leftmost
      * node is found (
      */
-    getLeftMost(beginRoot = this.root) {
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
         if (typeof beginRoot === 'number')
-            beginRoot = this.get(beginRoot, 'key');
+            beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.left)
                     return cur;
@@ -565,15 +577,16 @@ export class BinaryTree {
      * @param {N | null} [beginRoot] - The `node` parameter is an optional parameter of type `N` or `null`. It represents the
      * starting node from which we want to find the rightmost node. If no node is provided, the function will default to
      * using the root node of the data structure.
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns The `getRightMost` function returns the rightmost node in a binary tree. If the `node` parameter is provided,
      * it returns the rightmost node starting from that node. If the `node` parameter is not provided, it returns the
      * rightmost node starting from the root of the binary tree.
      */
-    getRightMost(beginRoot = this.root) {
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
         // TODO support get right most by passing key in
         if (!beginRoot)
             return beginRoot;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.right)
                     return cur;
@@ -593,14 +606,15 @@ export class BinaryTree {
     }
     /**
      * The function checks if a binary search tree is valid by traversing it either recursively or iteratively.
-     * @param {N | null} subTreeRoot - The `node` parameter represents the root node of a binary search tree (BST).
+     * @param {N | null} beginRoot - The `node` parameter represents the root node of a binary search tree (BST).
+     * @param iterationType - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns a boolean value.
      */
-    isSubtreeBST(subTreeRoot) {
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
         // TODO there is a bug
-        if (!subTreeRoot)
+        if (!beginRoot)
             return true;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const dfs = (cur, min, max) => {
                 if (!cur)
                     return true;
@@ -608,11 +622,11 @@ export class BinaryTree {
                     return false;
                 return dfs(cur.left, min, cur.key) && dfs(cur.right, cur.key, max);
             };
-            return dfs(subTreeRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
         }
         else {
             const stack = [];
-            let prev = Number.MIN_SAFE_INTEGER, curr = subTreeRoot;
+            let prev = Number.MIN_SAFE_INTEGER, curr = beginRoot;
             while (curr || stack.length > 0) {
                 while (curr) {
                     stack.push(curr);
@@ -631,116 +645,70 @@ export class BinaryTree {
      * The function isBST checks if the binary tree is valid binary search tree.
      * @returns The `isBST()` function is returning a boolean value.
      */
-    isBST() {
-        return this.isSubtreeBST(this.root);
-    }
-    /**
-     * The function calculates the size of a subtree by traversing it either recursively or iteratively.
-     * @param {N | null | undefined} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree in a
-     * binary tree.
-     * @returns the size of the subtree rooted at `subTreeRoot`.
-     */
-    getSubTreeSize(subTreeRoot) {
-        // TODO support key passed in
-        let size = 0;
-        if (!subTreeRoot)
-            return size;
-        if (this._loopType === 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;
-        }
+    isBST(iterationType = this.iterationType) {
+        if (this.root === null)
+            return true;
+        return this.isSubtreeBST(this.root, iterationType);
     }
     /**
-     * The function `subTreeForeach` adds a delta value to a specified property of each node in a subtree.
-     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a binary
+     * The function `subTreeTraverse` adds a delta value to a specified property of each node in a subtree.
+     * @param {N | BinaryTreeNodeKey | null} beginRoot - The `beginRoot` parameter represents the root node of a binary
      * tree or the ID of a node in the binary tree. It can also be `null` if there is no subtree to add to.
      * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
      * specifies the property of the binary tree node that should be modified. If not provided, it defaults to 'key'.
+     * @param iterationType  - The `iterationType` parameter is an optional parameter of type `IterationType`. It represents the type of loop
      * @returns a boolean value.
      */
-    subTreeForeach(subTreeRoot, callback) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'key');
-        if (!subTreeRoot)
-            return false;
-        if (this._loopType === LoopType.RECURSIVE) {
+    subTreeTraverse(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot);
+        const ans = [];
+        if (!beginRoot)
+            return ans;
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                callback(cur);
+                ans.push(callback(cur));
                 cur.left && _traverse(cur.left);
                 cur.right && _traverse(cur.right);
             };
-            _traverse(subTreeRoot);
+            _traverse(beginRoot);
         }
         else {
-            const stack = [subTreeRoot];
+            const stack = [beginRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                callback(cur);
+                ans.push(callback(cur));
                 cur.right && stack.push(cur.right);
                 cur.left && stack.push(cur.left);
             }
         }
-        return true;
-    }
-    /**
-     * The bfs function performs a breadth-first search on a binary tree, accumulating properties of each node based on a specified property name.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - An optional parameter that represents either a node or a property name.
-     * If a node is provided, the bfs algorithm will be performed starting from that node.
-     * If a property name is provided, the bfs algorithm will be performed starting from the root node, accumulating the specified property.
-     * @returns An instance of the `BinaryTreeNodeProperties` class with generic type `N`.
-     */
-    bfs(nodeOrPropertyName = 'key') {
-        this._clearResults();
-        const queue = new Queue([this.root]);
-        while (queue.size !== 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);
+        return ans;
     }
     /**
      * The dfs function performs a depth-first search traversal on a binary tree and returns the accumulated properties of
      * each node based on the specified pattern and property name.
+     * @param callback
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It represents the
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. If no `nodeOrPropertyName` is provided, the default value is `'key'`.
-     * @param loopType - The type of loop to use for the depth-first search traversal. The default value is `LoopType.ITERATIVE`.
+     * @param iterationType - The type of loop to use for the depth-first search traversal. The default value is `IterationType.ITERATIVE`.
      * @returns an instance of the BinaryTreeNodeProperties class, which contains the accumulated properties of the binary tree nodes based on the specified pattern and node or property name.
      */
-    dfs(pattern = 'in', nodeOrPropertyName = 'key', loopType = LoopType.ITERATIVE) {
-        this._clearResults();
-        if (loopType === LoopType.RECURSIVE) {
+    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
+        if (!beginRoot)
+            return [];
+        const ans = [];
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
                         if (node.left)
                             _traverse(node.left);
-                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                        ans.push(callback(node));
                         if (node.right)
                             _traverse(node.right);
                         break;
                     case 'pre':
-                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                        ans.push(callback(node));
                         if (node.left)
                             _traverse(node.left);
                         if (node.right)
@@ -751,23 +719,21 @@ export class BinaryTree {
                             _traverse(node.left);
                         if (node.right)
                             _traverse(node.right);
-                        this._accumulatedByPropertyName(node, nodeOrPropertyName);
+                        ans.push(callback(node));
                         break;
                 }
             };
-            this.root && _traverse(this.root);
+            _traverse(beginRoot);
         }
         else {
-            if (!this.root)
-                return this._getResultByPropertyName(nodeOrPropertyName);
             // 0: visit, 1: print
-            const stack = [{ opt: 0, node: this.root }];
+            const stack = [{ opt: 0, node: beginRoot }];
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (!cur || !cur.node)
                     continue;
                 if (cur.opt === 1) {
-                    this._accumulatedByPropertyName(cur.node, nodeOrPropertyName);
+                    ans.push(callback(cur.node));
                 }
                 else {
                     switch (pattern) {
@@ -795,61 +761,43 @@ export class BinaryTree {
                 }
             }
         }
-        return this._getResultByPropertyName(nodeOrPropertyName);
+        return ans;
     }
+    // --- start additional methods ---
     /**
      * The `listLevels` function collects nodes from a binary tree by a specified property and organizes them into levels.
-     * @param {N | null} node - The `node` parameter is a BinaryTreeNode object or null. It represents the root node of a binary tree. If it is null, the function will use the root node of the current binary tree instance.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that specifies the property of the `BinaryTreeNode` object to collect at each level. It can be one of the following values: 'key', 'val', or 'node'. If not provided, it defaults to 'key'.
-     * @returns A 2D array of `AbstractBinaryTreeNodeProperty<N>` objects.
+     * @param callback - The `callback` parameter is a function that takes a node and a level as parameters and returns a value.
+     * @param withLevel - The `withLevel` parameter is a boolean flag that determines whether to include the level of each node in the result. If `withLevel` is set to `true`, the function will include the level of each node in the result. If `withLevel` is set to `false` or not provided, the function will not include the level of each node in the result.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It represents the root node of a tree or null if the tree is empty.
+     * @param iterationType
      */
-    listLevels(node = this.root, nodeOrPropertyName = 'key') {
-        if (!node)
+    bfs(callback = this._defaultCallbackByKey, withLevel = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if (!beginRoot)
             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 === LoopType.RECURSIVE) {
+        const ans = [];
+        if (iterationType === IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
-                if (!levelsNodes[level])
-                    levelsNodes[level] = [];
-                collectByProperty(node, level);
+                callback && ans.push(callback(node, withLevel ? level : undefined));
                 if (node.left)
                     _recursive(node.left, level + 1);
                 if (node.right)
                     _recursive(node.right, level + 1);
             };
-            _recursive(node, 0);
+            _recursive(beginRoot, 0);
         }
         else {
-            const stack = [[node, 0]];
+            const stack = [[beginRoot, 0]];
             while (stack.length > 0) {
                 const head = stack.pop();
                 const [node, level] = head;
-                if (!levelsNodes[level])
-                    levelsNodes[level] = [];
-                collectByProperty(node, level);
+                callback && ans.push(callback(node, withLevel ? level : undefined));
                 if (node.right)
                     stack.push([node.right, level + 1]);
                 if (node.left)
                     stack.push([node.left, level + 1]);
             }
         }
-        return levelsNodes;
+        return ans;
     }
     /**
      * The function returns the predecessor of a given node in a binary tree.
@@ -870,17 +818,25 @@ export class BinaryTree {
             return node;
         }
     }
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     */
     /**
      * The `morris` function performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm.
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The property name of the nodes to retrieve or perform operations on during the traversal. It can be any valid property name of the nodes in the binary tree. If not provided, it defaults to 'key'.
+     * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter of type `N` or `null`. It represents the
      * @returns An array of BinaryTreeNodeProperties<N> objects.
      */
-    morris(pattern = 'in', nodeOrPropertyName = 'key') {
-        if (this.root === null)
+    morris(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root) {
+        if (beginRoot === null)
             return [];
-        this._clearResults();
-        let cur = this.root;
+        const ans = [];
+        let cur = beginRoot;
         const _reverseEdge = (node) => {
             let pre = null;
             let next = null;
@@ -896,7 +852,7 @@ export class BinaryTree {
             const tail = _reverseEdge(node);
             let cur = tail;
             while (cur) {
-                this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                ans.push(callback(cur));
                 cur = cur.right;
             }
             _reverseEdge(tail);
@@ -915,7 +871,7 @@ export class BinaryTree {
                             predecessor.right = null;
                         }
                     }
-                    this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                    ans.push(callback(cur));
                     cur = cur.right;
                 }
                 break;
@@ -925,7 +881,7 @@ export class BinaryTree {
                         const predecessor = this.getPredecessor(cur);
                         if (!predecessor.right) {
                             predecessor.right = cur;
-                            this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                            ans.push(callback(cur));
                             cur = cur.left;
                             continue;
                         }
@@ -934,7 +890,7 @@ export class BinaryTree {
                         }
                     }
                     else {
-                        this._accumulatedByPropertyName(cur, nodeOrPropertyName);
+                        ans.push(callback(cur));
                     }
                     cur = cur.right;
                 }
@@ -955,10 +911,10 @@ export class BinaryTree {
                     }
                     cur = cur.right;
                 }
-                _printEdge(this.root);
+                _printEdge(beginRoot);
                 break;
         }
-        return this._getResultByPropertyName(nodeOrPropertyName);
+        return ans;
     }
     /**
      * The function adds a new node to a binary tree if there is an available position.
@@ -1014,96 +970,4 @@ export class BinaryTree {
     _setSize(v) {
         this._size = v;
     }
-    /**
-     * The function `_clearResults` resets the values of several arrays used for tracking visited nodes and their
-     * properties.
-     */
-    _clearResults() {
-        this.visitedKey = [];
-        this.visitedVal = [];
-        this.visitedNode = [];
-    }
-    /**
-     * The function checks if a given property of a binary tree node matches a specified value, and if so, adds the node to
-     * a result array.
-     * @param {N} cur - The current node being processed.
-     * @param {(N | null | undefined)[]} result - An array that stores the matching nodes.
-     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is either a `BinaryTreeNodeKey` or a `N`
-     * type. It represents the property value that we are comparing against in the switch statement.
-     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to compare against when pushing nodes into the `result` array. It can be either `'key'`
-     * or `'val'`. If it is not provided or is not equal to `'key'` or `'val'`, the
-     * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
-     * stop after finding the first matching node or continue searching for all matching nodes. If `onlyOne` is set to
-     * `true`, the function will stop after finding the first matching node and return `true`. If `onlyOne
-     * @returns a boolean value indicating whether only one matching node should be pushed into the result array.
-     */
-    _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;
-        }
-    }
-    /**
-     * The function `_accumulatedByPropertyName` accumulates values from a given node based on the specified property name.
-     * @param {N} node - The `node` parameter is of type `N`, which represents a node in a data structure.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The `nodeOrPropertyName` parameter is an optional parameter that
-     * can be either a string representing a property name or a reference to a `Node` object. If it is a string, it
-     * specifies the property name to be used for accumulating values. If it is a `Node` object, it specifies
-     */
-    _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;
-        }
-    }
-    /**
-     * The time complexity of Morris traversal is O(n), it may slower than others
-     * The space complexity  Morris traversal is O(1) because no using stack
-     */
-    /**
-     * The function `_getResultByPropertyName` returns the corresponding property value based on the given node or property
-     * name.
-     * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
-     * can accept either a `NodeOrPropertyName` type or be undefined.
-     * @returns The method `_getResultByPropertyName` returns an instance of `BinaryTreeNodeProperties<N>`.
-     */
-    _getResultByPropertyName(nodeOrPropertyName = 'key') {
-        switch (nodeOrPropertyName) {
-            case 'key':
-                return this.visitedKey;
-            case 'val':
-                return this.visitedVal;
-            case 'node':
-                return this.visitedNode;
-            default:
-                return this.visitedKey;
-        }
-    }
 }