queue-typed 1.47.6 → 1.47.8

package/dist/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, Comparator } from '../../types';
-import { CP, IterableEntriesOrKeys, IterationType } from '../../types';
+import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, BTNodeExemplar, Comparator } from '../../types';
+import { CP, 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> {
@@ -33,17 +33,26 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
      */
     set right(v: N | undefined);
 }
+/**
+ * 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 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> {
     /**
-     * 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(elements?: IterableEntriesOrKeys<V>, options?: Partial<BSTOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BSTOptions>);
     protected _root?: N;
-    /**
-     * Get the root node of the binary tree.
-     */
     get root(): N | undefined;
     comparator: Comparator<BTNKey>;
     /**
@@ -55,45 +64,50 @@ 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;
+    /**
+     * 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.
+     */
     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.
-     *
-     * 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`.
      */
-    add(keyOrNode: BTNKey | N | null | undefined, value?: V): N | undefined;
     /**
      * 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, 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.
      */
+    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): 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(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) - 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.
      */
-    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: (V | undefined)[], isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (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.
@@ -113,7 +127,7 @@ 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): BTNKey;
+    lastKey(beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): BTNKey;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -138,7 +152,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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,
+     * 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`.
@@ -146,7 +160,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key: BTNKey | N | undefined, iterationType?: IterationType): N | undefined;
+    ensureNode(key: BSTNodeKeyOrNode<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.
@@ -170,7 +184,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): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<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.
@@ -196,7 +210,7 @@ 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): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<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.
@@ -236,11 +250,6 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns a boolean value.
      */
     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

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

@@ -45,11 +45,23 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
     }
 }
 exports.BSTNode = BSTNode;
+/**
+ * 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.
+ */
 class BST extends binary_tree_1.BinaryTree {
     /**
-     * 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(elements, options) {
         super([], options);
@@ -62,11 +74,8 @@ class BST extends binary_tree_1.BinaryTree {
         }
         this._root = undefined;
         if (elements)
-            this.init(elements);
+            this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
         return this._root;
     }
@@ -81,165 +90,156 @@ class BST extends binary_tree_1.BinaryTree {
     createNode(key, value) {
         return new BSTNode(key, value);
     }
+    /**
+     * 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.
+     */
     createTree(options) {
         return new BST([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
+    /**
+     * 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) - 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.
      */
-    add(keyOrNode, value) {
-        if (keyOrNode === null)
+    add(keyOrNodeOrEntry) {
+        if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
             return undefined;
-        // TODO support node as a parameter
-        let inserted;
+        }
         let newNode;
-        if (keyOrNode instanceof BSTNode) {
-            newNode = keyOrNode;
+        if (keyOrNodeOrEntry instanceof BSTNode) {
+            newNode = keyOrNodeOrEntry;
+        }
+        else if (this.isNodeKey(keyOrNodeOrEntry)) {
+            newNode = this.createNode(keyOrNodeOrEntry);
         }
-        else if (this.isNodeKey(keyOrNode)) {
-            newNode = this.createNode(keyOrNode, value);
+        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;
+            this._size++;
+            return this.root;
         }
-        else {
-            let cur = this.root;
-            let traversing = true;
-            while (traversing) {
-                if (cur !== undefined && newNode !== undefined) {
-                    if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
-                        if (newNode) {
-                            cur.value = newNode.value;
-                        }
-                        //Duplicates are not accepted.
-                        traversing = false;
-                        inserted = cur;
-                    }
-                    else if (this._compare(cur.key, newNode.key) === types_1.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) === types_1.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;
-                        }
-                    }
+        let current = this.root;
+        while (current !== undefined) {
+            if (this._compare(current.key, newNode.key) === types_1.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) === types_1.CP.gt) {
+                if (current.left === undefined) {
+                    current.left = newNode;
+                    newNode.parent = current;
+                    this._size++;
+                    return newNode;
                 }
-                else {
-                    traversing = false;
+                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(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(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.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
-        // TODO this addMany function is inefficient, it should be optimized
-        function hasNoUndefined(arr) {
-            return arr.indexOf(undefined) === -1;
-        }
-        if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
-            return super.addMany(keysOrNodes, data).map(n => n !== null && n !== void 0 ? n : undefined);
-        }
+    addMany(keysOrNodesOrEntries, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
-        const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
-        let sorted = [];
-        function _isNodeOrUndefinedTuple(arr) {
-            for (const [keyOrNode] of arr)
-                if (keyOrNode instanceof BSTNode)
-                    return true;
-            return false;
+        if (!isBalanceAdd) {
+            for (const kve of keysOrNodesOrEntries) {
+                const nn = this.add(kve);
+                inserted.push(nn);
+            }
+            return inserted;
         }
-        const _isBinaryTreeKeyOrNullTuple = (arr) => {
-            for (const [keyOrNode] of arr)
-                if (this.isNodeKey(keyOrNode))
-                    return true;
-            return false;
+        const realBTNExemplars = [];
+        const isRealBTNExemplar = (kve) => {
+            if (kve === undefined || kve === null)
+                return false;
+            return !(this.isEntry(kve) && (kve[0] === undefined || kve[0] === null));
         };
-        let sortedKeysOrNodes = [], sortedData = [];
-        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');
+        for (const kve of keysOrNodesOrEntries) {
+            isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
         }
-        sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-        sortedData = sorted.map(([, value]) => value);
-        const _dfs = (arr, data) => {
+        // TODO this addMany function is inefficient, it should be optimized
+        let sorted = [];
+        sorted = realBTNExemplars.sort((a, b) => {
+            let aR, bR;
+            if (this.isEntry(a))
+                aR = a[0];
+            else if (this.isRealNode(a))
+                aR = a.key;
+            else
+                aR = a;
+            if (this.isEntry(b))
+                bR = b[0];
+            else if (this.isRealNode(b))
+                bR = b.key;
+            else
+                bR = b;
+            return aR - bR;
+        });
+        const _dfs = (arr) => {
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            const newNode = this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
+            const newNode = this.add(arr[mid]);
             inserted.push(newNode);
-            _dfs(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
-            _dfs(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
+            _dfs(arr.slice(0, mid));
+            _dfs(arr.slice(mid + 1));
         };
         const _iterate = () => {
             const n = sorted.length;
@@ -250,7 +250,7 @@ class BST extends binary_tree_1.BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const newNode = this.add(sortedKeysOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        const newNode = this.add(sorted[m]);
                         inserted.push(newNode);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -259,7 +259,7 @@ class BST extends binary_tree_1.BinaryTree {
             }
         };
         if (iterationType === types_1.IterationType.RECURSIVE) {
-            _dfs(sortedKeysOrNodes, sortedData);
+            _dfs(sorted);
         }
         else {
             _iterate();
@@ -348,7 +348,7 @@ class BST extends binary_tree_1.BinaryTree {
      * 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,
+     * 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`.
@@ -356,7 +356,7 @@ class BST extends binary_tree_1.BinaryTree {
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+    ensureNode(key, iterationType = types_1.IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -383,7 +383,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method returns an array of nodes (`N[]`).
      */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-        beginRoot = this.ensureNotKey(beginRoot);
+        beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
@@ -464,7 +464,7 @@ class BST extends binary_tree_1.BinaryTree {
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
     lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
-        targetNode = this.ensureNotKey(targetNode);
+        targetNode = this.ensureNode(targetNode);
         const ans = [];
         if (!targetNode)
             return ans;
@@ -529,7 +529,7 @@ class BST extends binary_tree_1.BinaryTree {
                     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);
             };
@@ -546,7 +546,7 @@ class BST extends binary_tree_1.BinaryTree {
                         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]);
                     }
@@ -623,23 +623,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return balanced;
     }
-    /**
-     * 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) {
-        if (elements) {
-            for (const entryOrKey of elements) {
-                if (Array.isArray(entryOrKey)) {
-                    const [key, value] = entryOrKey;
-                    this.add(key, value);
-                }
-                else {
-                    this.add(entryOrKey);
-                }
-            }
-        }
-    }
     _setRoot(v) {
         if (v) {
             v.parent = undefined;