deque-typed 1.49.5 → 1.49.7

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNExemplar, BTNKeyOrNode } from '../../types';
+import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, KeyOrNodeOrEntry } from '../../types';
 import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -45,13 +45,13 @@ export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTN
 export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>> extends BinaryTree<K, V, N, TREE> implements IBinaryTree<K, V, N, 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 BTNExemplar objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry 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(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: BSTOptions<K>);
     protected _root?: N;
     get root(): N | undefined;
     protected _variant: BSTVariant;
@@ -74,27 +74,53 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      */
     createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
-     * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
-     */
-    isNode(exemplar: BTNExemplar<K, V, N>): exemplar is N;
-    /**
-     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar: BTNExemplar<K, V, N>, value?: V): N | undefined;
+    exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): N | undefined;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. Space for the recursive call stack in the worst case.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {K | N | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | undefined;
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     */
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
     /**
-     * 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(log n)
+     * Space Complexity: O(1)
+     *  - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      */
     /**
-     * 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(log n)
+     * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary tree, updating the value if the key already exists
      * or inserting a new node if the key is unique.
@@ -104,14 +130,15 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
      * node was not added.
      */
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V): N | undefined;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V): boolean;
     /**
-     * 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(k log n)
+     * Space Complexity: O(k)
+     * Adding each element individually in a balanced tree. 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(k log n)
+     * Space Complexity: O(k)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
      * balancing the tree after each addition.
@@ -122,41 +149,40 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * order. If not provided, undefined will be assigned as the value for each key or node.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
      * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
      * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when adding multiple keys or nodes. It has a default value of
      * `this.iterationType`, which suggests that it is a property of the current object.
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
     /**
-     * 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(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * 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)
+     * Space Complexity: O(n)
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
      * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
      * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
      * @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(beginRoot?: BSTNKeyOrNode<K, N>): K | undefined;
+    lastKey(beginRoot?: KeyOrNodeOrEntry<K, V, N>): K | undefined;
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
@@ -170,29 +196,14 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      */
     getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K;
-    /**
-     * 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 {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
-     * @returns either a node object (N) or undefined.
-     */
-    ensureNode(key: BSTNKeyOrNode<K, N>, 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)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
+     * /
+  
+     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The function `getNodes` returns an array of nodes that match a given identifier, using either a
      * recursive or iterative approach.
@@ -213,14 +224,15 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * 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?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, N>, 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
      * are either lesser or greater than a target node, depending on the specified comparison type.
@@ -239,14 +251,14 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @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?: BSTNKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): ReturnType<C>[];
     /**
-     * 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)
+     * Space Complexity: 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)
+     * Space Complexity: O(log n)
      *
      * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
      * ensures the tree is perfectly balanced.
@@ -270,8 +282,8 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * 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

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

@@ -57,24 +57,23 @@ exports.BSTNode = BSTNode;
 class BST extends binary_tree_1.BinaryTree {
     /**
      * 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 BTNExemplar objects that will be added to the
+     * the tree with optional keysOrNodesOrEntries and options.
+     * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry 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(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this._variant = types_1.BSTVariant.MIN;
+        this._variant = types_1.BSTVariant.STANDARD;
         if (options) {
             const { variant } = options;
-            if (variant) {
+            if (variant)
                 this._variant = variant;
-            }
         }
         this._root = undefined;
-        if (elements)
-            this.addMany(elements);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     get root() {
         return this._root;
@@ -104,31 +103,23 @@ class BST extends binary_tree_1.BinaryTree {
         return new BST([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof BSTNode;
-    }
-    /**
-     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * The function `exemplarToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
      * otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, where:
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, where:
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node.
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node.
      * @returns a node of type N or undefined.
      */
-    exemplarToNode(exemplar, value) {
+    exemplarToNode(keyOrNodeOrEntry, value) {
         let node;
-        if (exemplar === null || exemplar === undefined) {
+        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
             return;
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined || key === null) {
                 return;
             }
@@ -136,8 +127,8 @@ class BST extends binary_tree_1.BinaryTree {
                 node = this.createNode(key, value);
             }
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value);
         }
         else {
             return;
@@ -145,12 +136,62 @@ class BST extends binary_tree_1.BinaryTree {
         return node;
     }
     /**
-     * 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(log n)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. Space for the recursive call stack in the worst case.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
+     * otherwise it returns the key itself.
+     * @param {K | N | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`, or
+     * `undefined`.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
+     * @returns either a node object (N) or undefined.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = types_1.IterationType.ITERATIVE) {
+        let res;
+        if (this.isRealNode(keyOrNodeOrEntry)) {
+            res = keyOrNodeOrEntry;
+        }
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            if (keyOrNodeOrEntry[0])
+                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+        }
+        else {
+            if (keyOrNodeOrEntry)
+                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        }
+        return res;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BSTNode);
+    }
+    /**
+     * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the BSTNode class.
+     */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof BSTNode;
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *  - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      */
     /**
-     * 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(log n)
+     * Space Complexity: O(1)
      *
      * The `add` function adds a new node to a binary tree, updating the value if the key already exists
      * or inserting a new node if the key is unique.
@@ -163,11 +204,11 @@ class BST extends binary_tree_1.BinaryTree {
     add(keyOrNodeOrEntry, value) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
-            return;
+            return false;
         if (this.root === undefined) {
             this._setRoot(newNode);
             this._size++;
-            return this.root;
+            return true;
         }
         let current = this.root;
         while (current !== undefined) {
@@ -175,7 +216,7 @@ class BST extends binary_tree_1.BinaryTree {
                 // 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;
+                return true;
                 // } else {
                 // The key value is the same and the reference is the same, replace the entire node
                 // this._replaceNode(current, newNode);
@@ -187,7 +228,7 @@ class BST extends binary_tree_1.BinaryTree {
                     current.left = newNode;
                     newNode.parent = current;
                     this._size++;
-                    return newNode;
+                    return true;
                 }
                 current = current.left;
             }
@@ -196,20 +237,21 @@ class BST extends binary_tree_1.BinaryTree {
                     current.right = newNode;
                     newNode.parent = current;
                     this._size++;
-                    return newNode;
+                    return true;
                 }
                 current = current.right;
             }
         }
-        return undefined;
+        return false;
     }
     /**
-     * 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(k log n)
+     * Space Complexity: O(k)
+     * Adding each element individually in a balanced tree. 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(k log n)
+     * Space Complexity: O(k)
      *
      * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
      * balancing the tree after each addition.
@@ -220,7 +262,7 @@ class BST extends binary_tree_1.BinaryTree {
      * order. If not provided, undefined will be assigned as the value for each key or node.
      * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
      * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
      * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when adding multiple keys or nodes. It has a default value of
@@ -302,20 +344,19 @@ class BST extends binary_tree_1.BinaryTree {
         return inserted;
     }
     /**
-     * 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(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
      */
     /**
-     * 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)
+     * Space Complexity: O(n)
      *
      * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
      * leftmost node if the comparison result is greater than.
      * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
      * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
      * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
      * @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.
@@ -324,7 +365,7 @@ class BST extends binary_tree_1.BinaryTree {
         let current = this.ensureNode(beginRoot);
         if (!current)
             return undefined;
-        if (this._variant === types_1.BSTVariant.MIN) {
+        if (this._variant === types_1.BSTVariant.STANDARD) {
             // For BSTVariant.MIN, find the rightmost node
             while (current.right !== undefined) {
                 current = current.right;
@@ -339,12 +380,12 @@ class BST extends binary_tree_1.BinaryTree {
         return current.key;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
@@ -388,33 +429,14 @@ class BST extends binary_tree_1.BinaryTree {
         }
     }
     /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof BSTNode);
-    }
-    /**
-     * 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 {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
-     * `undefined`.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
-     * @returns either a node object (N) or undefined.
-     */
-    ensureNode(key, iterationType = types_1.IterationType.ITERATIVE) {
-        return this.isNotNodeInstance(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)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. Space for the recursive call stack in the worst case.
+     * /
+  
+     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The function `getNodes` returns an array of nodes that match a given identifier, using either a
      * recursive or iterative approach.
@@ -492,12 +514,13 @@ class BST extends binary_tree_1.BinaryTree {
         return ans;
     }
     /**
-     * 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)
+     * Space Complexity: O(log n)
+     * Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key. 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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(log n)
      *
      * The `lesserOrGreaterTraverse` function traverses a binary tree and returns an array of nodes that
      * are either lesser or greater than a target node, depending on the specified comparison type.
@@ -557,12 +580,12 @@ class BST extends binary_tree_1.BinaryTree {
         }
     }
     /**
-     * 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)
+     * Space Complexity: 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)
+     * Space Complexity: O(log n)
      *
      * The `perfectlyBalance` function balances a binary search tree by adding nodes in a way that
      * ensures the tree is perfectly balanced.
@@ -621,8 +644,8 @@ class BST extends binary_tree_1.BinaryTree {
      * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * 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
@@ -692,7 +715,7 @@ class BST extends binary_tree_1.BinaryTree {
     _compare(a, b) {
         const extractedA = this.extractor(a);
         const extractedB = this.extractor(b);
-        const compared = this.variant === types_1.BSTVariant.MIN ? extractedA - extractedB : extractedB - extractedA;
+        const compared = this.variant === types_1.BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
         return compared > 0 ? types_1.CP.gt : compared < 0 ? types_1.CP.lt : types_1.CP.eq;
     }
 }