deque-typed 1.47.5 → 1.47.7

package/src/data-structures/binary-tree/bst.ts

@@ -5,7 +5,17 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
+import type {
+  BSTNested,
+  BSTNodeKeyOrNode,
+  BSTNodeNested,
+  BSTOptions,
+  BTNCallback,
+  BTNKey,
+  BTNodeExemplar,
+  BTNodePureExemplar,
+  Comparator
+} from '../../types';
 import { CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -62,36 +72,51 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
+/**
+ * 1. Node Order: Each node's left child has a lesser value, and the right child has a greater value.
+ * 2. Unique Keys: No duplicate keys in a standard BST.
+ * 3. Efficient Search: Enables quick search, minimum, and maximum operations.
+ * 4. Inorder Traversal: Yields nodes in ascending order.
+ * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
+ * 6. Balance Variability: Can become unbalanced; special types maintain balance.
+ * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ */
 export 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> {
 
-  override 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.
+   * This is the constructor function for a binary search tree class in TypeScript, which initializes
+   * the tree with optional elements and options.
+   * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+   * binary search tree.
+   * @param [options] - The `options` parameter is an optional object that can contain additional
+   * configuration options for the binary search tree. It can have the following properties:
    */
-  constructor(options?: BSTOptions) {
-    super(options);
+  constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BSTOptions>) {
+    super([], options);
+
     if (options) {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options }
-    } else {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
+      const { comparator } = options;
+      if (comparator) {
+        this.comparator = comparator;
+      }
     }
+
     this._root = undefined;
+
+    if (elements) this.addMany(elements);
   }
 
   protected override _root?: N;
 
-  /**
-   * Get the root node of the binary tree.
-   */
   override get root(): N | undefined {
     return this._root;
   }
 
+  comparator: Comparator<BTNKey> = (a, b) => a - b
+
   /**
    * 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
@@ -104,8 +129,18 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return new BSTNode<V, N>(key, value) as N;
   }
 
-  override createTree(options?: BSTOptions): TREE {
-    return new BST<V, N, TREE>({ ...this.options, ...options }) as TREE;
+  /**
+   * The function creates a new binary search tree with the specified options.
+   * @param [options] - The `options` parameter is an optional object that allows you to customize the
+   * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
+   * that defines various options for creating a binary search tree.
+   * @returns a new instance of the BST class with the specified options.
+   */
+  override createTree(options?: Partial<BSTOptions>): TREE {
+    return new BST<V, N, TREE>([], {
+      iterationType: this.iterationType,
+      comparator: this.comparator, ...options
+    }) as TREE;
   }
 
   /**
@@ -117,158 +152,145 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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.
    *
-   * The `add` function adds a new node to a binary search tree based on the provided key and value.
-   * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-   * following types:
-   * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-   * key or node being added to the binary search tree.
-   * @returns The method `add` returns a node (`N`) that was inserted into the binary search tree. If
-   * no node was inserted, it returns `undefined`.
+   * The `add` function adds a new node to a binary search tree, either by key or by providing a node
+   * object.
+   * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+   * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
+   * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
    */
-  override add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined {
-    if (keyOrNode === null) return undefined;
-    // TODO support node as a parameter
-    let inserted: N | undefined;
+  override add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined {
+    if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
+      return undefined;
+    }
+
     let newNode: N | undefined;
-    if (keyOrNode instanceof BSTNode) {
-      newNode = keyOrNode;
-    } else if (this.isNodeKey(keyOrNode)) {
-      newNode = this.createNode(keyOrNode, value);
+    if (keyOrNodeOrEntry instanceof BSTNode) {
+      newNode = keyOrNodeOrEntry;
+    } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+      newNode = this.createNode(keyOrNodeOrEntry);
+    } else if (this.isEntry(keyOrNodeOrEntry)) {
+      const [key, value] = keyOrNodeOrEntry;
+      if (key === undefined || key === null) {
+        return;
+      } else {
+        newNode = this.createNode(key, value);
+      }
     } else {
-      newNode = undefined;
+      return;
     }
+
     if (this.root === undefined) {
       this._setRoot(newNode);
-      this._size = this.size + 1;
-      inserted = this.root;
-    } else {
-      let cur = this.root;
-      let traversing = true;
-      while (traversing) {
-        if (cur !== undefined && newNode !== undefined) {
-          if (this._compare(cur.key, newNode.key) === CP.eq) {
-            if (newNode) {
-              cur.value = newNode.value;
-            }
-            //Duplicates are not accepted.
-            traversing = false;
-            inserted = cur;
-          } else if (this._compare(cur.key, newNode.key) === CP.gt) {
-            // Traverse left of the node
-            if (cur.left === undefined) {
-              if (newNode) {
-                newNode.parent = cur;
-              }
-              //Add to the left of the current node
-              cur.left = newNode;
-              this._size = this.size + 1;
-              traversing = false;
-              inserted = cur.left;
-            } else {
-              //Traverse the left of the current node
-              if (cur.left) cur = cur.left;
-            }
-          } else if (this._compare(cur.key, newNode.key) === CP.lt) {
-            // Traverse right of the node
-            if (cur.right === undefined) {
-              if (newNode) {
-                newNode.parent = cur;
-              }
-              //Add to the right of the current node
-              cur.right = newNode;
-              this._size = this.size + 1;
-              traversing = false;
-              inserted = cur.right;
-            } else {
-              //Traverse the left of the current node
-              if (cur.right) cur = cur.right;
-            }
-          }
-        } else {
-          traversing = false;
+      this._size++;
+      return this.root;
+    }
+
+    let current = this.root;
+    while (current !== undefined) {
+      if (this._compare(current.key, newNode.key) === CP.eq) {
+        // if (current !== newNode) {
+        // The key value is the same but the reference is different, update the value of the existing node
+        this._replaceNode(current, newNode);
+        return newNode;
+
+        // } else {
+        // The key value is the same and the reference is the same, replace the entire node
+        // this._replaceNode(current, newNode);
+
+        //   return;
+        // }
+      } else if (this._compare(current.key, newNode.key) === CP.gt) {
+        if (current.left === undefined) {
+          current.left = newNode;
+          newNode.parent = current;
+          this._size++;
+          return newNode;
+        }
+        current = current.left;
+      } else {
+        if (current.right === undefined) {
+          current.right = newNode;
+          newNode.parent = current;
+          this._size++;
+          return newNode;
         }
+        current = current.right;
       }
     }
-    return inserted;
+
+    return 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(k log n) - Adding each element individually in a balanced tree.
+   * Space Complexity: O(k) - Additional space is required for the sorted array.
    */
 
   /**
-   * 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(k log n) - Adding each element individually in a balanced tree.
+   * Space Complexity: O(k) - Additional space is required for the sorted array.
    *
-   * The `addMany` function is used to efficiently add multiple keys or nodes with corresponding data
-   * to a binary search tree.
-   * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes to be added to the
-   * binary search tree. Each element can be of type `BTNKey` (binary tree node key), `N` (binary tree
-   * node), or `undefined`.
-   * @param {(V | undefined)[]} [data] - An optional array of values to associate with the keys or
-   * nodes being added. If provided, the length of the `data` array must be the same as the length of
-   * the `keysOrNodes` array.
+   * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
+   * unbalanced manner, and returns an array of the inserted nodes.
+   * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
+   * binary tree.
    * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-   * adding the nodes. The default value is `true`.
+   * adding the nodes. The default value is true.
    * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-   * type of iteration to use when adding multiple keys or nodes to the binary search tree. It has a
-   * default value of `this.iterationType`, which means it will use the iteration type specified in the
-   * current instance of the binary search tree
-   * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+   * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
+   * value of `this.iterationType`, which means it will use the iteration type specified by the binary
+   * tree instance.
+   * @returns The `addMany` function returns an array of `N` or `undefined` values.
    */
   override addMany(
-    keysOrNodes: (BTNKey | N | undefined)[],
-    data?: (V | undefined)[],
+    keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>,
     isBalanceAdd = true,
-    iterationType = this.options.iterationType
+    iterationType = this.iterationType
   ): (N | undefined)[] {
-    // TODO this addMany function is inefficient, it should be optimized
-    function hasNoUndefined(arr: (BTNKey | N | undefined)[]): arr is (BTNKey | N)[] {
-      return arr.indexOf(undefined) === -1;
+    const inserted: (N | undefined)[] = []
+    if (!isBalanceAdd) {
+      for (const kve of keysOrNodesOrEntries) {
+        const nn = this.add(kve)
+        inserted.push(nn);
+      }
+      return inserted;
     }
+    const realBTNExemplars: BTNodePureExemplar<V, N>[] = [];
 
-    if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
-      return super.addMany(keysOrNodes, data).map(n => n ?? undefined);
+    const isRealBTNExemplar = (kve: BTNodeExemplar<V, N>): kve is BTNodePureExemplar<V, N> => {
+      if (kve === undefined || kve === null) return false;
+      return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
     }
 
-    const inserted: (N | undefined)[] = [];
-    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
-      (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
-    );
+    for (const kve of keysOrNodesOrEntries) {
+      isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
+    }
 
-    let sorted = [];
+    // TODO this addMany function is inefficient, it should be optimized
+    let sorted: BTNodePureExemplar<V, N>[] = [];
 
-    function _isNodeOrUndefinedTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
-      for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
-      return false;
-    }
+    sorted = realBTNExemplars.sort((a, b) => {
+      let aR: number, bR: number;
+      if (this.isEntry(a)) aR = a[0]
+      else if (this.isRealNode(a)) aR = a.key
+      else aR = a;
 
-    const _isBinaryTreeKeyOrNullTuple = (arr: [BTNKey | N, V][]): arr is [BTNKey, V][] => {
-      for (const [keyOrNode] of arr) if (this.isNodeKey(keyOrNode)) return true;
-      return false;
-    };
+      if (this.isEntry(b)) bR = b[0]
+      else if (this.isRealNode(b)) bR = b.key
+      else bR = b;
 
-    let sortedKeysOrNodes: (number | N | undefined)[] = [],
-      sortedData: (V | undefined)[] | undefined = [];
+      return aR - bR;
+    })
 
-    if (_isNodeOrUndefinedTuple(combinedArr)) {
-      sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
-    } else if (_isBinaryTreeKeyOrNullTuple(combinedArr)) {
-      sorted = combinedArr.sort((a, b) => a[0] - b[0]);
-    } else {
-      throw new Error('Invalid input keysOrNodes');
-    }
-    sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-    sortedData = sorted.map(([, value]) => value);
-    const _dfs = (arr: (BTNKey | undefined | N)[], data?: (V | undefined)[]) => {
+
+    const _dfs = (arr: BTNodePureExemplar<V, N>[]) => {
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
-      const newNode = this.add(arr[mid], data?.[mid]);
+      const newNode = this.add(arr[mid]);
       inserted.push(newNode);
-      _dfs(arr.slice(0, mid), data?.slice(0, mid));
-      _dfs(arr.slice(mid + 1), data?.slice(mid + 1));
+      _dfs(arr.slice(0, mid));
+      _dfs(arr.slice(mid + 1));
     };
     const _iterate = () => {
       const n = sorted.length;
@@ -279,7 +301,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
           const [l, r] = popped;
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
-            const newNode = this.add(sortedKeysOrNodes[m], sortedData?.[m]);
+            const newNode = this.add(sorted[m]);
             inserted.push(newNode);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
@@ -288,7 +310,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       }
     };
     if (iterationType === IterationType.RECURSIVE) {
-      _dfs(sortedKeysOrNodes, sortedData);
+      _dfs(sorted);
     } else {
       _iterate();
     }
@@ -297,8 +319,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * 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.
    */
 
   /**
@@ -316,7 +338,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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 = this.root, iterationType = this.options.iterationType): BTNKey {
+  lastKey(beginRoot: BSTNodeKeyOrNode<N> = this.root, iterationType = this.iterationType): BTNKey {
     if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
     else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -324,7 +346,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
   /**
    * 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.
    */
 
   /**
@@ -367,7 +389,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+   * 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 `ensureNode` returns the node corresponding to the given key if it is a node key,
    * otherwise it returns the key itself.
    * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
    * `undefined`.
@@ -375,15 +402,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
    * @returns either a node object (N) or undefined.
    */
-  override ensureNotKey(key: BTNKey | N | undefined, iterationType = IterationType.ITERATIVE): N | undefined {
+  override ensureNode(key: BSTNodeKeyOrNode<N>, iterationType = IterationType.ITERATIVE): N | undefined {
     return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
   }
 
-  /**
-   * 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.
@@ -411,10 +433,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
-    beginRoot: BTNKey | N | undefined = this.root,
-    iterationType = this.options.iterationType
+    beginRoot: BSTNodeKeyOrNode<N> = this.root,
+    iterationType = this.iterationType
   ): N[] {
-    beginRoot = this.ensureNotKey(beginRoot);
+    beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
     const ans: N[] = [];
 
@@ -492,10 +514,10 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   lesserOrGreaterTraverse<C extends BTNCallback<N>>(
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = CP.lt,
-    targetNode: BTNKey | N | undefined = this.root,
-    iterationType = this.options.iterationType
+    targetNode: BSTNodeKeyOrNode<N> = this.root,
+    iterationType = this.iterationType
   ): ReturnType<C>[] {
-    targetNode = this.ensureNotKey(targetNode);
+    targetNode = this.ensureNode(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
     if (!this.root) return ans;
@@ -531,18 +553,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * 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(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.
    */
 
   /**
@@ -556,7 +568,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * values:
    * @returns The function `perfectlyBalance` returns a boolean value.
    */
-  perfectlyBalance(iterationType = this.options.iterationType): boolean {
+  perfectlyBalance(iterationType = this.iterationType): boolean {
     const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     this.clear();
@@ -567,7 +579,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.value);
+        this.add([midNode.key, midNode.value]);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -584,7 +596,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
             debugger;
-            this.add(midNode.key, midNode.value);
+            this.add([midNode.key, midNode.value]);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -595,8 +607,18 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * 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.
    */
 
   /**
@@ -608,7 +630,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * to check if the AVL tree is balanced. It can have two possible values:
    * @returns a boolean value.
    */
-  isAVLBalanced(iterationType = this.options.iterationType): boolean {
+  isAVLBalanced(iterationType = this.iterationType): boolean {
     if (!this.root) return true;
 
     let balanced = true;
@@ -652,6 +674,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return balanced;
   }
 
+
   protected _setRoot(v: N | undefined) {
     if (v) {
       v.parent = undefined;
@@ -668,7 +691,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * than), CP.lt (less than), or CP.eq (equal).
    */
   protected _compare(a: BTNKey, b: BTNKey): CP {
-    const compared = this.options.comparator!(a, b);
+    const compared = this.comparator(a, b);
     if (compared > 0) return CP.gt;
     else if (compared < 0) return CP.lt;
     else return CP.eq;