data-structure-typed 1.37.2 → 1.37.4

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> {
@@ -14,79 +14,121 @@ export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNod
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBinaryTree<N> {
     /**
-     * The constructor function initializes a binary search tree object with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.
+     * The constructor function initializes a binary search tree object with an optional comparator
+     * function.
+     * @param {BSTOptions} [options] - An optional object that contains configuration options for the
+     * binary search tree.
      */
     constructor(options?: BSTOptions);
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
-     * that will be stored in the node.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
+     * represents the value associated with the node in a binary search tree.
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     /**
-     * The `add` function adds a new node to a binary search tree, either by creating a new node or by updating an existing
-     * node with the same ID.
-     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N`
-     * (which represents a binary tree node) or `null`.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
-     * being added to the binary search tree.
-     * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
+     * The `add` function in a binary search tree class inserts a new node with a given key and value
+     * into the tree.
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+     * `BinaryTreeNodeKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+     * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
+     * binary search tree.
+     * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
+     * was not added or if the parameters were invalid, it returns null or undefined.
      */
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
     /**
-     * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
-     * manner.
-     * @param {[BinaryTreeNodeKey | N , N['val']][]} keysOrNodes - The `keysOrNodes` parameter in the `addMany` function is an array of
-     * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
-     * to the binary search tree.
+     * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
+     * maintaining balance.
+     * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+     * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
+     * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
+     * `null
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @param iterationType - The `iterationType` parameter determines the type of iteration to be used.
+     * It can have two possible values:
+     * @returns The `addMany` function 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
-     * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
-     * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
+     * The function returns the first node in the binary tree that matches the given node property and
+     * callback.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+     * property of the binary tree node that you want to search for. It can be either a specific key
+     * value (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
+     * whether a node matches the desired property.
+     * @param callback - The `callback` parameter is a function that is used to determine whether a node
+     * matches the desired property. It takes a node as input and returns a boolean value indicating
+     * whether the node matches the property or not. If no callback function is provided, the default
+     * callback function `_defaultCallbackByKey` is used
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+     * the root node from which the search should begin.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary tree. It can have one of the following values:
+     * @returns either the first node that matches the given nodeProperty and callback, or null if no
+     * matching node is found.
      */
-    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 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.
+     * The function `lastKey` returns the key of the rightmost node if the comparison result is less
+     * than, the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise.
+     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting point for finding the last
+     * key in a binary tree. It represents the root node of the subtree from which the search for the
+     * last key should begin. If no specific `beginRoot` is provided, the search will start from the root
+     * of the entire binary
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when finding the last key. It determines whether the iteration should be performed in
+     * pre-order, in-order, or post-order.
+     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+     * the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise. If no node is found, it returns 0.
      */
-    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
-     * `N` type. It represents the property of the binary tree node that you want to compare with.
-     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * specifies the property name to use for comparison. 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 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
-     * @returns an array of nodes (type N).
+     * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
+     * using either recursive or iterative traversal.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+     * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
+     * generic type `N`.
+     * @param callback - The `callback` parameter is a function that takes a node as input and returns a
+     * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
+     * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+     * a
+     * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
+     * the first node that matches the nodeProperty. If set to true, the function will return an array
+     * containing only that node. If set to false (default), the function will continue the traversal and
+     * return an array containing all nodes that match the node
+     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
+     * specifies the root node of the binary tree from which the traversal should begin. If `beginRoot`
+     * is `null`, an empty array will be returned.
+     * @param iterationType - The `iterationType` parameter determines the type of iteration used to
+     * traverse the binary tree. It can have one of the following values:
+     * @returns an array of nodes (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
+     * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
+     * nodes that have a key value lesser or greater than a target key value.
+     * @param callback - The `callback` parameter is a function that will be called for each node that
+     * meets the condition specified by the `lesserOrGreater` parameter. It takes a node as an argument
+     * and returns a value.
+     * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
+     * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
+     * of the following values:
+     * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+     * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
+     * start. It can be either a reference to a specific node (`N`), the key of a node
+     * (`BinaryTreeNodeKey`), or `null` to
+     * @param iterationType - The `iterationType` parameter determines whether the traversal should be
+     * done recursively or iteratively. It can have two possible values:
+     * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    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.
@@ -97,24 +139,29 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends Binar
      * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
      */
     /**
-     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
-     * constructs a balanced binary search tree using either a recursive or iterative approach.
-     * @returns The function `perfectlyBalance()` returns a boolean value.
+     * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
+     * ensures the tree is perfectly balanced.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building a balanced binary search tree. It can have two possible
+     * values:
+     * @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.
+     * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
+     * to check if the AVL tree is balanced. It can have two possible values:
      * @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
-     * greater than, less than, or equal to the second ID.
-     * @param {BinaryTreeNodeKey} a - "a" is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
-     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
-     * than), or CP.eq (equal).
+     * The function compares two values using a comparator function and returns whether the first value
+     * is greater than, less than, or equal to the second value.
+     * @param {BinaryTreeNodeKey} a - The parameter "a" is of type BinaryTreeNodeKey.
+     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code represents a BinaryTreeNodeKey.
+     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
+     * than), CP.lt (less than), or CP.eq (equal).
      */
     protected _compare(a: BinaryTreeNodeKey, b: BinaryTreeNodeKey): CP;
 }

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

@@ -1,4 +1,4 @@
-import { CP, LoopType } from '../../types';
+import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -8,8 +8,10 @@ export class BSTNode extends BinaryTreeNode {
 }
 export class BST extends BinaryTree {
     /**
-     * The constructor function initializes a binary search tree object with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.
+     * The constructor function initializes a binary search tree object with an optional comparator
+     * function.
+     * @param {BSTOptions} [options] - An optional object that contains configuration options for the
+     * binary search tree.
      */
     constructor(options) {
         super(options);
@@ -23,23 +25,24 @@ export class BST extends BinaryTree {
     }
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
-     * identify each node in the binary tree.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
-     * that will be stored in the node.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+     * the new node. It is used to determine the position of the node in the binary search tree.
+     * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
+     * represents the value associated with the node in a binary search tree.
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
     createNode(key, val) {
         return new BSTNode(key, val);
     }
     /**
-     * The `add` function adds a new node to a binary search tree, either by creating a new node or by updating an existing
-     * node with the same ID.
-     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N`
-     * (which represents a binary tree node) or `null`.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
-     * being added to the binary search tree.
-     * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
+     * The `add` function in a binary search tree class inserts a new node with a given key and value
+     * into the tree.
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+     * `BinaryTreeNodeKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+     * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
+     * binary search tree.
+     * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
+     * was not added or if the parameters were invalid, it returns null or undefined.
      */
     add(keyOrNode, val) {
         // TODO support node as a parameter
@@ -117,16 +120,19 @@ export class BST extends BinaryTree {
         return inserted;
     }
     /**
-     * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
-     * manner.
-     * @param {[BinaryTreeNodeKey | N , N['val']][]} keysOrNodes - The `keysOrNodes` parameter in the `addMany` function is an array of
-     * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
-     * to the binary search tree.
+     * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
+     * maintaining balance.
+     * @param {[BinaryTreeNodeKey | N, N['val']][]} arr - The `arr` parameter in the `addMany` function
+     * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
+     * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
+     * `null
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * @param iterationType - The `iterationType` parameter determines the type of iteration to be used.
+     * It can have two possible values:
+     * @returns The `addMany` function returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
         // TODO this addMany function is inefficient, it should be optimized
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
@@ -187,7 +193,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             recursive(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -196,50 +202,77 @@ export class BST extends BinaryTree {
         return inserted;
     }
     /**
-     * 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
-     * generic type `N`. It represents the property of the binary tree node that you want to search for.
-     * @param callback  - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
-     * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
+     * The function returns the first node in the binary tree that matches the given node property and
+     * callback.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter is used to specify the
+     * property of the binary tree node that you want to search for. It can be either a specific key
+     * value (`BinaryTreeNodeKey`) or a custom callback function (`MapCallback<N>`) that determines
+     * whether a node matches the desired property.
+     * @param callback - The `callback` parameter is a function that is used to determine whether a node
+     * matches the desired property. It takes a node as input and returns a boolean value indicating
+     * whether the node matches the property or not. If no callback function is provided, the default
+     * callback function `_defaultCallbackByKey` is used
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
+     * the root node from which the search should begin.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when searching for nodes in the binary tree. It can have one of the following values:
+     * @returns either the first node that matches the given nodeProperty and callback, or null if no
+     * matching node is found.
      */
-    get(nodeProperty, callback = this._defaultCallbackByKey) {
+    get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
-        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 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.
+     * The function `lastKey` returns the key of the rightmost node if the comparison result is less
+     * than, the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise.
+     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting point for finding the last
+     * key in a binary tree. It represents the root node of the subtree from which the search for the
+     * last key should begin. If no specific `beginRoot` is provided, the search will start from the root
+     * of the entire binary
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed when finding the last key. It determines whether the iteration should be performed in
+     * pre-order, in-order, or post-order.
+     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+     * the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey() {
+    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
         else
-            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+            return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
     }
     /**
-     * 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
-     * `N` type. It represents the property of the binary tree node that you want to compare with.
-     * @param callback - The `callback` parameter is a function that takes a node as a parameter and returns a value.
-     * specifies the property name to use for comparison. 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 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
-     * @returns an array of nodes (type N).
+     * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
+     * using either recursive or iterative traversal.
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter represents the property
+     * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
+     * generic type `N`.
+     * @param callback - The `callback` parameter is a function that takes a node as input and returns a
+     * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
+     * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+     * a
+     * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
+     * the first node that matches the nodeProperty. If set to true, the function will return an array
+     * containing only that node. If set to false (default), the function will continue the traversal and
+     * return an array containing all nodes that match the node
+     * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the traversal. It
+     * specifies the root node of the binary tree from which the traversal should begin. If `beginRoot`
+     * is `null`, an empty array will be returned.
+     * @param iterationType - The `iterationType` parameter determines the type of iteration used to
+     * traverse the binary tree. It can have one of the following values:
+     * @returns an array of nodes (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) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === nodeProperty) {
@@ -292,48 +325,57 @@ export class BST extends BinaryTree {
     }
     // --- start additional functions
     /**
-     * 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
+     * The `lesserOrGreaterTraverse` function traverses a binary tree and applies a callback function to
+     * nodes that have a key value lesser or greater than a target key value.
+     * @param callback - The `callback` parameter is a function that will be called for each node that
+     * meets the condition specified by the `lesserOrGreater` parameter. It takes a node as an argument
+     * and returns a value.
+     * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
+     * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
+     * of the following values:
+     * @param {N | BinaryTreeNodeKey | null} targetNode - The `targetNode` parameter in the
+     * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
+     * start. It can be either a reference to a specific node (`N`), the key of a node
+     * (`BinaryTreeNodeKey`), or `null` to
+     * @param iterationType - The `iterationType` parameter determines whether the traversal should be
+     * done recursively or iteratively. It can have two possible values:
+     * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, node) {
-        if (typeof node === 'number')
-            node = this.get(node);
+    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+        if (typeof targetNode === 'number')
+            targetNode = this.get(targetNode);
         const ans = [];
-        if (!node)
-            return [];
-        const key = node.key;
+        if (!targetNode)
+            return ans;
+        const targetKey = targetNode.key;
         if (!this.root)
-            return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+            return ans;
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.key, key);
+                const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                     _traverse(cur.right);
             };
             _traverse(this.root);
-            return true;
+            return ans;
         }
         else {
             const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.key, key);
+                    const compared = this._compare(cur.key, targetKey);
                     if (compared === lesserOrGreater)
                         ans.push(callback(cur));
-                    if (cur.left && this._compare(cur.left.key, key) === lesserOrGreater)
+                    if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, key) === lesserOrGreater)
+                    if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
                         queue.push(cur.right);
                 }
             }
@@ -350,16 +392,19 @@ export class BST extends BinaryTree {
      * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
      */
     /**
-     * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
-     * constructs a balanced binary search tree using either a recursive or iterative approach.
-     * @returns The function `perfectlyBalance()` returns a boolean value.
+     * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
+     * ensures the tree is perfectly balanced.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building a balanced binary search tree. It can have two possible
+     * values:
+     * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance() {
+    perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -391,15 +436,17 @@ export class BST extends BinaryTree {
         }
     }
     /**
-     * The function `isAVLBalanced` checks if a binary tree is balanced according to the AVL tree property.
+     * The function checks if a binary tree is AVL balanced using either recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is used to determine the method of iteration
+     * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced() {
+    isAVLBalanced(iterationType = this.iterationType) {
         var _a, _b;
         if (!this.root)
             return true;
         let balanced = true;
-        if (this.loopType === LoopType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -441,12 +488,12 @@ export class BST extends BinaryTree {
         return balanced;
     }
     /**
-     * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
-     * greater than, less than, or equal to the second ID.
-     * @param {BinaryTreeNodeKey} a - "a" is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
-     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
-     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
-     * than), or CP.eq (equal).
+     * The function compares two values using a comparator function and returns whether the first value
+     * is greater than, less than, or equal to the second value.
+     * @param {BinaryTreeNodeKey} a - The parameter "a" is of type BinaryTreeNodeKey.
+     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code represents a BinaryTreeNodeKey.
+     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
+     * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
         const compared = this._comparator(a, b);