data-structure-typed 1.37.2 → 1.37.3

package/lib/data-structures/binary-tree/binary-tree.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BFSCallback, BFSCallbackReturn, BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions, MapCallback, MapCallbackReturn } from '../../types';
-import { BinaryTreeDeletedResult, DFSOrderPattern, FamilyPosition, LoopType } from '../../types';
+import { BinaryTreeDeletedResult, DFSOrderPattern, FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 export declare class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
     /**
@@ -54,8 +54,8 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
     private _size;
     get size(): number;
     private _loopType;
-    get loopType(): LoopType;
-    set loopType(v: LoopType);
+    get iterationType(): IterationType;
+    set iterationType(v: IterationType);
     /**
      * The `_swap` function swaps the location of two nodes in a binary tree.
      * @param {N} srcNode - The source node that you want to _swap with the destination node.
@@ -128,9 +128,10 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @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?: N | BinaryTreeNodeKey | null): number;
+    getHeight(beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): number;
     protected _defaultCallbackByKey: MapCallback<N>;
     /**
      * The `getMinHeight` function calculates the minimum height of a binary tree using either a recursive or iterative
@@ -138,9 +139,10 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @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?: N | null): number;
+    getMinHeight(beginRoot?: N | null, iterationType?: IterationType): number;
     /**
      * The function checks if a binary tree is perfectly balanced by comparing the minimum height and the height of the
      * tree.
@@ -159,18 +161,21 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * 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: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null): N[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
      * 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.
      * 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: BinaryTreeNodeKey | N, callback?: MapCallback<N>): boolean;
+    has(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, beginRoot?: N | null, iterationType?: IterationType): boolean;
     /**
      * The function returns the first node that matches the given property name and value, or null if no matching node is
      * found.
@@ -179,10 +184,12 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * It represents the property of the binary tree node that you want to search for.
      * 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: BinaryTreeNodeKey | N, callback?: MapCallback<N>): N | null;
+    get(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, beginRoot?: N | null, iterationType?: IterationType): N | 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.
@@ -200,60 +207,65 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      * @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?: N | BinaryTreeNodeKey | null): N | null;
+    getLeftMost(beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): N | null;
     /**
      * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or iteratively using tail
      * recursion optimization.
      * @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?: N | null): N | null;
+    getRightMost(beginRoot?: N | null, iterationType?: IterationType): N | null;
     /**
      * 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: N | null): boolean;
+    isSubtreeBST(beginRoot: N, iterationType?: IterationType): boolean;
     /**
      * The function isBST checks if the binary tree is valid binary search tree.
      * @returns The `isBST()` function is returning a boolean value.
      */
-    isBST(): boolean;
+    isBST(iterationType?: IterationType): boolean;
     /**
      * The function `subTreeTraverse` 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
+     * @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.
      */
-    subTreeTraverse(callback?: MapCallback<N>, subTreeRoot?: N | BinaryTreeNodeKey | null): MapCallbackReturn<N>[];
+    subTreeTraverse(callback?: MapCallback<N>, beginRoot?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): MapCallbackReturn<N>[];
     /**
      * 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 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(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null, loopType?: LoopType): MapCallbackReturn<N>[];
+    dfs(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null, iterationType?: IterationType): MapCallbackReturn<N>[];
     /**
      * 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 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
      */
-    bfs(callback?: BFSCallback<N>, withLevel?: boolean, node?: N | null): BFSCallbackReturn<N>[];
+    bfs(callback?: BFSCallback<N>, withLevel?: boolean, beginRoot?: N | null, iterationType?: IterationType): BFSCallbackReturn<N>[];
     /**
      * The function returns the predecessor of a given node in a binary tree.
      * @param node - The parameter `node` is a BinaryTreeNode object, representing a node in a binary tree.
@@ -266,11 +278,15 @@ export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTr
      */
     /**
      * 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 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(callback?: MapCallback<N>, pattern?: DFSOrderPattern): MapCallbackReturn<N>[];
+    morris(callback?: MapCallback<N>, pattern?: DFSOrderPattern, beginRoot?: N | null): MapCallbackReturn<N>[];
     /**
      * The function adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter is of type `N | null`, which means it can either be a node of

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,11 +86,11 @@ export class BinaryTree {
         // TODO placeholder node may need redesigned
         this._root = null;
         this._size = 0;
-        this._loopType = LoopType.ITERATIVE;
+        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;
         }
     }
     /**
@@ -110,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;
     }
     /**
@@ -334,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);
         if (!beginRoot)
             return -1;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
@@ -376,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;
@@ -442,13 +444,14 @@ export class BinaryTree {
      * 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, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root) {
+    getNodes(nodeProperty, callback = this._defaultCallbackByKey, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (callback(cur) === nodeProperty) {
                     ans.push(cur);
@@ -485,11 +488,13 @@ export class BinaryTree {
      * @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.
      * 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, callback = this._defaultCallbackByKey) {
+    has(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         // TODO may support finding node by value equal
-        return this.getNodes(nodeProperty, callback, true).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
@@ -499,13 +504,15 @@ export class BinaryTree {
      * It represents the property of the binary tree node that you want to search for.
      * 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, callback = this._defaultCallbackByKey) {
+    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, callback, 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
@@ -535,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);
         if (!beginRoot)
             return beginRoot;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.left)
                     return cur;
@@ -569,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;
@@ -597,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;
@@ -612,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);
@@ -635,33 +645,36 @@ 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);
+    isBST(iterationType = this.iterationType) {
+        if (this.root === null)
+            return true;
+        return this.isSubtreeBST(this.root, iterationType);
     }
     /**
      * The function `subTreeTraverse` 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
+     * @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.
      */
-    subTreeTraverse(callback = this._defaultCallbackByKey, subTreeRoot = this.root) {
-        if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot);
+    subTreeTraverse(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+        if (typeof beginRoot === 'number')
+            beginRoot = this.get(beginRoot);
         const ans = [];
-        if (!subTreeRoot)
+        if (!beginRoot)
             return ans;
-        if (this._loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (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();
                 ans.push(callback(cur));
@@ -677,14 +690,14 @@ export class BinaryTree {
      * @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 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(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, loopType = LoopType.ITERATIVE) {
+    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
@@ -753,17 +766,16 @@ export class BinaryTree {
     // --- 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 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
      */
-    bfs(callback = this._defaultCallbackByKey, withLevel = false, node) {
-        if (!node)
-            node = this.root;
-        if (!node)
+    bfs(callback = this._defaultCallbackByKey, withLevel = false, beginRoot = this.root, iterationType = this.iterationType) {
+        if (!beginRoot)
             return [];
         const ans = [];
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
                 callback && ans.push(callback(node, withLevel ? level : undefined));
                 if (node.left)
@@ -771,10 +783,10 @@ export class BinaryTree {
                 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;
@@ -812,15 +824,19 @@ export class BinaryTree {
      */
     /**
      * 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 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(callback = this._defaultCallbackByKey, pattern = 'in') {
-        if (this.root === null)
+    morris(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root) {
+        if (beginRoot === null)
             return [];
         const ans = [];
-        let cur = this.root;
+        let cur = beginRoot;
         const _reverseEdge = (node) => {
             let pre = null;
             let next = null;
@@ -895,7 +911,7 @@ export class BinaryTree {
                     }
                     cur = cur.right;
                 }
-                _printEdge(this.root);
+                _printEdge(beginRoot);
                 break;
         }
         return ans;

package/lib/data-structures/binary-tree/bst.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, MapCallback, MapCallbackReturn } from '../../types';
-import { CP } from '../../types';
+import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> {
@@ -45,9 +45,10 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean): (N | null | undefined)[];
+    addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][], isBalanceAdd?: boolean, iterationType?: IterationType): (N | null | undefined)[];
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
@@ -58,13 +59,12 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      */
     get(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>): N | null;
     /**
-     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
-     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
-     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
-     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * lastKey returns the last key in a binary tree. If the binary tree is empty, it returns 0.
+     * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to begin
+     * the search for the last key.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a recursive or iterative approach to search for the last key.
      */
-    lastKey(): BinaryTreeNodeKey;
+    lastKey(beginRoot?: N | null, iterationType?: IterationType): BinaryTreeNodeKey;
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
      * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
@@ -75,18 +75,20 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
      * @param beginRoot - The `beginRoot` parameter is an optional parameter that specifies the root node from which to
+     * @param iterationType
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null): N[];
+    getNodes(nodeProperty: BinaryTreeNodeKey | N, callback?: MapCallback<N>, onlyOne?: boolean, beginRoot?: N | null, iterationType?: IterationType): N[];
     /**
      * The `lesserOrGreaterTraverse` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
      * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type), `BinaryTreeNodeKey`, or `null`. It
      * represents the node in the binary tree to which the delta value will be added.
      * @param lesserOrGreater - The `lesserOrGreater` parameter is an optional parameter that specifies whether the delta
+     * @param targetNode - The `targetNode` parameter is an optional parameter that specifies the node in the binary tree
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies whether to use a
      */
-    lesserOrGreaterTraverse(callback: MapCallback<N> | undefined, lesserOrGreater: CP | undefined, node: N | BinaryTreeNodeKey | null): MapCallbackReturn<N>;
+    lesserOrGreaterTraverse(callback?: MapCallback<N>, lesserOrGreater?: CP, targetNode?: N | BinaryTreeNodeKey | null, iterationType?: IterationType): MapCallbackReturn<N>;
     /**
      * Balancing Adjustment:
      * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
@@ -101,12 +103,12 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * constructs a balanced binary search tree using either a recursive or iterative approach.
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
-    perfectlyBalance(): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
      * @returns a boolean value.
      */
-    isAVLBalanced(): boolean;
+    isAVLBalanced(iterationType?: IterationType): boolean;
     protected _comparator: BSTComparator;
     /**
      * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is