data-structure-typed 1.47.4 → 1.47.6

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

@@ -92,19 +92,21 @@ export class BinaryTreeNode {
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree {
-    options;
+    iterationType = IterationType.ITERATIVE;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
-    constructor(options) {
+    constructor(elements, options) {
         if (options) {
-            this.options = { iterationType: IterationType.ITERATIVE, ...options };
-        }
-        else {
-            this.options = { iterationType: IterationType.ITERATIVE };
+            const { iterationType } = options;
+            if (iterationType) {
+                this.iterationType = iterationType;
+            }
         }
         this._size = 0;
+        if (elements)
+            this.init(elements);
     }
     _root;
     /**
@@ -130,13 +132,8 @@ export class BinaryTree {
         return new BinaryTreeNode(key, value);
     }
     createTree(options) {
-        return new BinaryTree({ ...this.options, ...options });
+        return new BinaryTree([], { iterationType: this.iterationType, ...options });
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -197,8 +194,9 @@ export class BinaryTree {
         return inserted;
     }
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
+     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
@@ -247,10 +245,6 @@ export class BinaryTree {
         this.clear();
         return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -346,8 +340,7 @@ export class BinaryTree {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -363,7 +356,7 @@ export class BinaryTree {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -409,7 +402,7 @@ export class BinaryTree {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
@@ -456,6 +449,7 @@ export class BinaryTree {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
+     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
      */
     /**
      * Time Complexity: O(n)
@@ -471,10 +465,6 @@ export class BinaryTree {
     isPerfectlyBalanced(beginRoot = this.root) {
         return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -500,7 +490,7 @@ export class BinaryTree {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `N`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         beginRoot = this.ensureNotKey(beginRoot);
@@ -538,10 +528,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      *
@@ -562,15 +548,11 @@ export class BinaryTree {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -592,7 +574,7 @@ export class BinaryTree {
      * nodes are visited during the search.
      * @returns a value of type `N | null | undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
@@ -644,6 +626,10 @@ export class BinaryTree {
             }
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
@@ -658,10 +644,6 @@ export class BinaryTree {
     ensureNotKey(key, iterationType = IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -684,11 +666,15 @@ export class BinaryTree {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
             callback = (node => node);
         return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -703,10 +689,6 @@ export class BinaryTree {
     isEmpty() {
         return this.size === 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -738,7 +720,7 @@ export class BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -754,7 +736,7 @@ export class BinaryTree {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
@@ -795,7 +777,7 @@ export class BinaryTree {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
         // TODO support get right most by passing key in
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -819,7 +801,7 @@ export class BinaryTree {
         }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -834,7 +816,7 @@ export class BinaryTree {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
         // TODO there is a bug
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
@@ -881,15 +863,11 @@ export class BinaryTree {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.options.iterationType) {
+    isBST(iterationType = this.iterationType) {
         if (this.root === null)
             return true;
         return this.isSubtreeBST(this.root, iterationType);
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -912,7 +890,7 @@ export class BinaryTree {
      * the `callback` function on each node in the subtree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const ans = [];
         if (!beginRoot)
@@ -952,6 +930,10 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -986,10 +968,6 @@ export class BinaryTree {
     isNodeKey(potentialKey) {
         return typeof potentialKey === 'number';
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1119,10 +1097,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1144,7 +1118,7 @@ export class BinaryTree {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
@@ -1196,10 +1170,6 @@ export class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1221,7 +1191,7 @@ export class BinaryTree {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         const levelsNodes = [];
         if (!beginRoot)
@@ -1313,10 +1283,6 @@ export class BinaryTree {
         }
         return y;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -1420,6 +1386,10 @@ export class BinaryTree {
         }
         return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -1448,14 +1418,6 @@ export class BinaryTree {
         }
         return newTree;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
     /**
      * The `map` function creates a new tree by applying a callback function to each entry in the current
      * tree.
@@ -1469,6 +1431,14 @@ export class BinaryTree {
         }
         return newTree;
     }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
     /**
      * The `reduce` function iterates over the entries of a tree and applies a callback function to each
      * entry, accumulating a single value.
@@ -1500,7 +1470,7 @@ export class BinaryTree {
     *[Symbol.iterator](node = this.root) {
         if (!node)
             return;
-        if (this.options.iterationType === IterationType.ITERATIVE) {
+        if (this.iterationType === IterationType.ITERATIVE) {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {
@@ -1554,6 +1524,19 @@ export class BinaryTree {
         };
         display(beginRoot);
     }
+    init(elements) {
+        if (elements) {
+            for (const entryOrKey of elements) {
+                if (Array.isArray(entryOrKey)) {
+                    const [key, value] = entryOrKey;
+                    this.add(key, value);
+                }
+                else {
+                    this.add(entryOrKey);
+                }
+            }
+        }
+    }
     _displayAux(node, options) {
         const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
         const emptyDisplayLayout = [['─'], 1, 0, 0];

package/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
-import { CP, IterationType } from '../../types';
+import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, Comparator } from '../../types';
+import { CP, IterableEntriesOrKeys, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
@@ -34,18 +34,18 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
     set right(v: N | undefined);
 }
 export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>, TREE extends BST<V, N, TREE> = BST<V, N, BSTNested<V, N>>> extends BinaryTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
-    options: BSTOptions;
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
      * for the binary search tree.
      */
-    constructor(options?: BSTOptions);
+    constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<BSTOptions>);
     protected _root?: N;
     /**
      * Get the root node of the binary tree.
      */
     get root(): N | undefined;
+    comparator: Comparator<BTNKey>;
     /**
      * The function creates a new binary search tree node with the given key and value.
      * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -55,11 +55,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
     createNode(key: BTNKey, value?: V): N;
-    createTree(options?: BSTOptions): TREE;
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
-     * Space Complexity: O(1) - Constant space is used.
-     */
+    createTree(options?: Partial<BSTOptions>): TREE;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -74,8 +70,8 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      */
     add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
@@ -97,10 +93,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType | undefined): (N | undefined)[];
+    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -117,10 +113,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): BTNKey;
+    lastKey(beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): BTNKey;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -137,6 +133,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
     getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    /**
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
@@ -147,10 +147,6 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns either a node object (N) or undefined.
      */
     ensureNotKey(key: BTNKey | N | undefined, iterationType?: IterationType): N | undefined;
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -174,7 +170,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType | undefined): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BTNKey | N | undefined, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -200,19 +196,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType | undefined): ReturnType<C>[];
-    /**
-     * 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.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * 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).
-     */
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BTNKey | N | undefined, iterationType?: IterationType): ReturnType<C>[];
     /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(n) - Building a balanced tree from a sorted array.
@@ -225,10 +212,19 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType | undefined): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * 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.
+     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+     *
+     * Use Cases and Efficiency:
+     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+     * 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).
+     */
+    /**
+     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(n) - Visiting each node once.
@@ -239,7 +235,12 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType?: IterationType | undefined): boolean;
+    isAVLBalanced(iterationType?: IterationType): boolean;
+    /**
+     * Time Complexity: O(n) - Visiting each node once.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     */
+    init(elements: IterableEntriesOrKeys<V>): void;
     protected _setRoot(v: N | undefined): void;
     /**
      * The function compares two values using a comparator function and returns whether the first value