priority-queue-typed 1.53.9 → 1.54.1

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

@@ -6,43 +6,33 @@ const queue_1 = require("../queue");
 const utils_1 = require("../../utils");
 const common_1 = require("../../common");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
+    /**
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
+     */
     constructor(key, value) {
         super(key, value);
         this.parent = undefined;
         this._left = undefined;
         this._right = undefined;
     }
-    /**
-     * The function returns the value of the `_left` property.
-     * @returns The `_left` property of the current object is being returned.
-     */
     get left() {
         return this._left;
     }
-    /**
-     * The function sets the left child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
-     * instance of the `NODE` class or `undefined`.
-     */
     set left(v) {
         if (v) {
             v.parent = this;
         }
         this._left = v;
     }
-    /**
-     * The function returns the right node of a binary tree or undefined if there is no right node.
-     * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
-     * `undefined`.
-     */
     get right() {
         return this._right;
     }
-    /**
-     * The function sets the right child of a node and updates the parent reference of the child.
-     * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
-     * `NODE` object or `undefined`.
-     */
     set right(v) {
         if (v) {
             v.parent = this;
@@ -118,12 +108,13 @@ exports.BSTNode = BSTNode;
  */
 class BST extends binary_tree_1.BinaryTree {
     /**
-     * This is the constructor function for a Binary Search Tree class in TypeScript.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable that can contain either keys, nodes, entries, or raw elements. These elements will be
-     * added to the binary search tree during the construction of the object.
-     * @param [options] - An optional object that contains additional options for the Binary Search Tree.
-     * It can include a comparator function that defines the order of the elements in the tree.
+     * This TypeScript constructor initializes a binary search tree with optional options and adds
+     * elements if provided.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain elements of type `BTNRep<K, V, BSTNode<K, V>>` or `R`. It is used to
+     * initialize the binary search tree with keys, nodes, entries, or raw data.
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
@@ -159,43 +150,28 @@ class BST extends binary_tree_1.BinaryTree {
         if (keysNodesEntriesOrRaws)
             this.addMany(keysNodesEntriesOrRaws);
     }
-    /**
-     * The function returns the root node of a tree structure.
-     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
-     */
     get root() {
         return this._root;
     }
-    /**
-     * The above function is a getter method in TypeScript that returns the value of the private property
-     * `_isReverse`.
-     * @returns The `isReverse` property of the object, which is a boolean value.
-     */
     get isReverse() {
         return this._isReverse;
     }
-    /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
-     */
     get comparator() {
         return this._comparator;
     }
-    /**
-     * This function returns the value of the `_specifyComparable` property.
-     * @returns The method `specifyComparable()` is being returned, which is a getter method for the
-     * `_specifyComparable` property.
-     */
     get specifyComparable() {
         return this._specifyComparable;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new BSTNode with the given key and value and returns it.
      * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
      * being created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the node being created.
-     * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
+     * @returns The method is returning a new instance of the BSTNode class, casted as the BSTNode<K, V> type.
      */
     createNode(key, value) {
         return new BSTNode(key, this._isMapMode ? undefined : value);
@@ -204,14 +180,12 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `createTree` function in TypeScript overrides the default options with the provided options to
-     * create a new Binary Search Tree.
-     * @param [options] - The `options` parameter in the `createTree` method is an optional object that
-     * can contain the following properties:
-     * @returns A new instance of a Binary Search Tree (BST) is being returned with the specified options
-     * and properties inherited from the current instance.
+     * 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 has the
+     * following properties:
+     * @returns a new instance of the BST class with the provided options.
      */
-    // @ts-ignore
     createTree(options) {
         return new BST([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
@@ -221,8 +195,8 @@ class BST extends binary_tree_1.BinaryTree {
      *
      * The function ensures the existence of a node in a data structure and returns it, or undefined if
      * it doesn't exist.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R`, which represents the key, node,
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R`, which represents the key, node,
      * entry, or raw element that needs to be ensured in the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter is an optional
      * parameter that specifies the type of iteration to be used when ensuring a node. It has a default
@@ -230,44 +204,50 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning either the node that was ensured or `undefined` if the node could
      * not be ensured.
      */
-    ensureNode(keyNodeEntryOrRaw, iterationType = this.iterationType) {
+    ensureNode(keyNodeOrEntry, iterationType = this.iterationType) {
         var _a;
-        return (_a = super.ensureNode(keyNodeEntryOrRaw, iterationType)) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = super.ensureNode(keyNodeOrEntry, iterationType)) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of the BSTNode class.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `BSTNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-        return keyNodeEntryOrRaw instanceof BSTNode;
+    isNode(keyNodeOrEntry) {
+        return keyNodeOrEntry instanceof BSTNode;
     }
     /**
-     * The function "override isKey" checks if a key is comparable based on a given comparator.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function "override isValidKey" checks if a key is comparable based on a given comparator.
      * @param {any} key - The `key` parameter is a value that will be checked to determine if it is of
      * type `K`.
-     * @returns The `override isKey(key: any): key is K` function is returning a boolean value based on
+     * @returns The `override isValidKey(key: any): key is K` function is returning a boolean value based on
      * the result of the `isComparable` function with the condition `this._compare !==
      * this._DEFAULT_COMPARATOR`.
      */
-    isKey(key) {
+    isValidKey(key) {
         return (0, utils_1.isComparable)(key, this._specifyComparable !== undefined);
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The `add` function in TypeScript adds a new node to a binary search tree based on the key value.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, BSTNode<K, V>>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
      * key in the binary search tree. If provided, it will be stored in the node along with the key.
      * @returns a boolean value.
      */
-    add(keyNodeEntryOrRaw, value) {
-        const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    add(keyNodeOrEntry, value) {
+        const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
         if (newNode === undefined)
             return false;
         if (this._root === undefined) {
@@ -293,7 +273,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.left;
+                if (current.left !== null)
+                    current = current.left;
             }
             else {
                 if (current.right === undefined) {
@@ -303,7 +284,8 @@ class BST extends binary_tree_1.BinaryTree {
                     this._size++;
                     return true;
                 }
-                current = current.right;
+                if (current.right !== null)
+                    current = current.right;
             }
         }
         return false;
@@ -336,8 +318,10 @@ class BST extends binary_tree_1.BinaryTree {
             valuesIterator = values[Symbol.iterator]();
         }
         if (!isBalanceAdd) {
-            for (const kve of keysNodesEntriesOrRaws) {
+            for (let kve of keysNodesEntriesOrRaws) {
                 const value = valuesIterator === null || valuesIterator === void 0 ? void 0 : valuesIterator.next().value;
+                if (this.isRaw(kve))
+                    kve = this._toEntryFn(kve);
                 inserted.push(this.add(kve, value));
             }
             return inserted;
@@ -351,23 +335,21 @@ class BST extends binary_tree_1.BinaryTree {
         let sorted = [];
         sorted = realBTNExemplars.sort(({ key: a }, { key: b }) => {
             let keyA, keyB;
-            if (this.isEntry(a))
+            if (this.isRaw(a))
+                keyA = this._toEntryFn(a)[0];
+            else if (this.isEntry(a))
                 keyA = a[0];
             else if (this.isRealNode(a))
                 keyA = a.key;
-            else if (this._toEntryFn) {
-                keyA = this._toEntryFn(a)[0];
-            }
             else {
                 keyA = a;
             }
-            if (this.isEntry(b))
+            if (this.isRaw(b))
+                keyB = this._toEntryFn(b)[0];
+            else if (this.isEntry(b))
                 keyB = b[0];
             else if (this.isRealNode(b))
                 keyB = b.key;
-            else if (this._toEntryFn) {
-                keyB = this._toEntryFn(b)[0];
-            }
             else {
                 keyB = b;
             }
@@ -377,15 +359,23 @@ class BST extends binary_tree_1.BinaryTree {
             return 0;
         });
         const _dfs = (arr) => {
+            var _a;
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            const { key, value, orgIndex } = arr[mid];
+            let { key, value } = arr[mid];
+            const { orgIndex } = arr[mid];
+            if (this.isRaw(key)) {
+                const entry = this._toEntryFn(key);
+                key = entry[0];
+                value = (_a = entry[1]) !== null && _a !== void 0 ? _a : value;
+            }
             inserted[orgIndex] = this.add(key, value);
             _dfs(arr.slice(0, mid));
             _dfs(arr.slice(mid + 1));
         };
         const _iterate = () => {
+            var _a;
             const n = sorted.length;
             const stack = [[0, n - 1]];
             while (stack.length > 0) {
@@ -394,7 +384,13 @@ class BST extends binary_tree_1.BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const { key, value, orgIndex } = sorted[m];
+                        let { key, value } = sorted[m];
+                        const { orgIndex } = sorted[m];
+                        if (this.isRaw(key)) {
+                            const entry = this._toEntryFn(key);
+                            key = entry[0];
+                            value = (_a = entry[1]) !== null && _a !== void 0 ? _a : value;
+                        }
                         inserted[orgIndex] = this.add(key, value);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -410,35 +406,23 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `merge` function overrides the base class method by adding elements from another
-     * binary search tree.
-     * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
-     * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
-     */
-    merge(anotherTree) {
-        this.addMany(anotherTree, [], false);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
      *
      * The function `search` in TypeScript overrides the search behavior in a binary tree structure based
      * on specified criteria.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
-     * `keyNodeEntryRawOrPredicate` parameter in the `override search` method can accept one of the
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The
+     * `keyNodeEntryOrPredicate` parameter in the `override search` method can accept one of the
      * following types:
      * @param [onlyOne=false] - The `onlyOne` parameter is a boolean flag that determines whether the
      * search should stop after finding the first matching node. If `onlyOne` is set to `true`, the
      * search will return as soon as a matching node is found. If `onlyOne` is set to `false`, the
      * @param {C} callback - The `callback` parameter in the `override search` function is a function
      * that will be called on each node that matches the search criteria. It is of type `C`, which
-     * extends `NodeCallback<NODE>`. The callback function should accept a node of type `NODE` as its
+     * extends `NodeCallback<BSTNode<K, V>>`. The callback function should accept a node of type `BSTNode<K, V>` as its
      * argument and
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `override search`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `override search`
      * method represents the node from which the search operation will begin. It is the starting point
      * for searching within the tree data structure. The method ensures that the `startNode` is a valid
      * node before proceeding with the search operation. If the `
@@ -450,26 +434,26 @@ class BST extends binary_tree_1.BinaryTree {
      * structure based on the provided key, predicate, and other options. The search results are
      * collected in an array and returned as the output of the method.
      */
-    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
-        if (keyNodeEntryRawOrPredicate === undefined)
+    search(keyNodeEntryOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
+        if (keyNodeEntryOrPredicate === undefined)
             return [];
-        if (keyNodeEntryRawOrPredicate === null)
+        if (keyNodeEntryOrPredicate === null)
             return [];
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
         let predicate;
-        const isRange = this.isRange(keyNodeEntryRawOrPredicate);
+        const isRange = this.isRange(keyNodeEntryOrPredicate);
         // Set predicate based on parameter type
         if (isRange) {
-            predicate = node => keyNodeEntryRawOrPredicate.isInRange(node.key, this._comparator);
+            predicate = node => keyNodeEntryOrPredicate.isInRange(node.key, this._comparator);
         }
         else {
-            predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+            predicate = this._ensurePredicate(keyNodeEntryOrPredicate);
         }
         const isToLeftByRange = (cur) => {
             if (isRange) {
-                const range = keyNodeEntryRawOrPredicate;
+                const range = keyNodeEntryOrPredicate;
                 const leftS = this.isReverse ? range.high : range.low;
                 const leftI = this.isReverse ? range.includeHigh : range.includeLow;
                 return (leftI && this._compare(cur.key, leftS) >= 0) || (!leftI && this._compare(cur.key, leftS) > 0);
@@ -478,7 +462,7 @@ class BST extends binary_tree_1.BinaryTree {
         };
         const isToRightByRange = (cur) => {
             if (isRange) {
-                const range = keyNodeEntryRawOrPredicate;
+                const range = keyNodeEntryOrPredicate;
                 const rightS = this.isReverse ? range.low : range.high;
                 const rightI = this.isReverse ? range.includeLow : range.includeLow;
                 return (rightI && this._compare(cur.key, rightS) <= 0) || (!rightI && this._compare(cur.key, rightS) < 0);
@@ -501,8 +485,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (this.isRealNode(cur.right) && isToRightByRange(cur))
                         dfs(cur.right);
                 }
-                else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-                    const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+                else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+                    const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
                     if (this.isRealNode(cur.left) &&
                         benchmarkKey !== null &&
                         benchmarkKey !== undefined &&
@@ -538,8 +522,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (this.isRealNode(cur.right) && isToRightByRange(cur))
                         stack.push(cur.right);
                 }
-                else if (!this._isPredicate(keyNodeEntryRawOrPredicate)) {
-                    const benchmarkKey = this._extractKey(keyNodeEntryRawOrPredicate);
+                else if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+                    const benchmarkKey = this._extractKey(keyNodeEntryOrPredicate);
                     if (this.isRealNode(cur.right) &&
                         benchmarkKey !== null &&
                         benchmarkKey !== undefined &&
@@ -563,16 +547,16 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(k + log n)
      *
      * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
      * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
      * either a `Range` object or an array of two elements representing the range boundaries.
      * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
      * function that is used to process each node that is found within the specified range during the
-     * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+     * search operation. It is of type `NodeCallback<BSTNode<K, V>>`, where `BSTNode<K, V>` is the type of nodes in the
      * data structure.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter in the `rangeSearch`
      * function represents the node from which the search for nodes within the specified range will
      * begin. It is the starting point for the range search operation.
      * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
@@ -588,12 +572,12 @@ class BST extends binary_tree_1.BinaryTree {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
-     * This function retrieves a node based on a given keyNodeEntryRawOrPredicate within a binary search tree structure.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The `keyNodeEntryRawOrPredicate`
-     * parameter can be of type `BTNRep<K, V, NODE>`, `R`, or `NodePredicate<NODE>`.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} startNode - The `startNode` parameter in the `getNode` method
+     * This function retrieves a node based on a given keyNodeEntryOrPredicate within a binary search tree structure.
+     * @param {BTNRep<K, V, BSTNode<K, V>> | NodePredicate<BSTNode<K, V>>} keyNodeEntryOrPredicate - The `keyNodeEntryOrPredicate`
+     * parameter can be of type `BTNRep<K, V, BSTNode<K, V>>`, `R`, or `NodePredicate<BSTNode<K, V>>`.
+     * @param {BSTNOptKeyOrNode<K, BSTNode<K, V>>} startNode - The `startNode` parameter in the `getNode` method
      * is used to specify the starting point for searching nodes in the binary search tree. If no
      * specific starting point is provided, the default value is set to `this._root`, which is the root
      * node of the binary search tree.
@@ -601,14 +585,14 @@ class BST extends binary_tree_1.BinaryTree {
      * parameter that specifies the type of iteration to be used. It has a default value of
      * `this.iterationType`, which means it will use the iteration type defined in the class instance if
      * no value is provided when calling the method.
-     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<NODE>`).
-     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryRawOrPredicate, beginning at
+     * @returns The `getNode` method is returning an optional binary search tree node (`OptNode<BSTNode<K, V>>`).
+     * It is using the `getNodes` method to find the node based on the provided keyNodeEntryOrPredicate, beginning at
      * the specified root node (`startNode`) and using the specified iteration type. The method then
      * returns the first node found or `undefined` if no node is found.
      */
-    getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         var _a;
-        return (_a = this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Time complexity: O(n)
@@ -622,7 +606,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {DFSOrderPattern} [pattern=IN] - The "pattern" parameter in the code snippet refers to the
      * order in which the Depth-First Search (DFS) algorithm visits the nodes in a tree or graph. It can
      * take one of the following values:
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the depth-first search traversal. It can be either a root node, a key-value pair, or a
      * node entry. If not specified, the default value is the root of the tree.
      * @param {IterationType} [iterationType=ITERATIVE] - The `iterationType` parameter specifies the
@@ -642,7 +626,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node
      * visited during the breadth-first search. It should take a single argument, which is the current
      * node being visited, and it can return a value of any type.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for the breadth-first search. It can be either a root node, a key-value pair, or an entry
      * object. If no value is provided, the default value is the root of the tree.
      * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
@@ -660,9 +644,9 @@ class BST extends binary_tree_1.BinaryTree {
      * The function overrides the listLevels method from the superclass and returns an array of arrays
      * containing the results of the callback function applied to each level of the tree.
      * @param {C} callback - The `callback` parameter is a generic type `C` that extends
-     * `NodeCallback<NODE>`. It represents a callback function that will be called for each node in the
+     * `NodeCallback<BSTNode<K, V>>`. It represents a callback function that will be called for each node in the
      * tree during the iteration process.
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter is the starting
+     * @param {BTNRep<K, V, BSTNode<K, V>>} startNode - The `startNode` parameter is the starting
      * point for listing the levels of the binary tree. It can be either a root node of the tree, a
      * key-value pair representing a node in the tree, or a key representing a node in the tree. If no
      * value is provided, the root of
@@ -686,7 +670,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
      * traverse nodes that are lesser, greater, or both than the `targetNode`. It accepts the values -1,
      * 0, or 1, where:
-     * @param {BTNRep<K, V, NODE> | R} targetNode - The `targetNode` parameter is the node in
+     * @param {BTNRep<K, V, BSTNode<K, V>>} targetNode - The `targetNode` parameter is the node in
      * the binary tree that you want to start traversing from. It can be specified either by providing
      * the key of the node, the node itself, or an entry containing the key and value of the node. If no
      * `targetNode` is provided,
@@ -822,7 +806,8 @@ class BST extends binary_tree_1.BinaryTree {
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
-                    node = node.left;
+                    if (node.left !== null)
+                        node = node.left;
                 }
                 else {
                     node = stack[stack.length - 1];
@@ -845,7 +830,25 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return balanced;
     }
-    // @ts-ignore
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior for a binary search tree by
+     * applying a callback function to each entry and creating a new tree with the results.
+     * @param callback - A function that will be called for each entry in the BST. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the BST itself.
+     * @param [options] - The `options` parameter in the `override map` method is of type `BSTOptions<MK,
+     * MV, MR>`. It is an optional parameter that allows you to specify additional options for the Binary
+     * Search Tree (BST) being created in the `map` method. These options could include configuration
+     * @param {any} [thisArg] - The `thisArg` parameter in the `override map` method is used to specify
+     * the value of `this` that should be used when executing the `callback` function. It allows you to
+     * set the context or scope in which the callback function will be called. This can be useful when
+     * you want
+     * @returns The `map` method is returning a new Binary Search Tree (`BST`) instance with the entries
+     * transformed by the provided callback function.
+     */
     map(callback, options, thisArg) {
         const newTree = new BST([], options);
         let index = 0;
@@ -855,24 +858,43 @@ class BST extends binary_tree_1.BinaryTree {
         return newTree;
     }
     /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns The `cloned` object is being returned.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this._clone(cloned);
+        return cloned;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-     * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+     * @param {BTNRep<K, V, BSTNode<K, V>>} keyNodeOrEntry - A variable that can be of
+     * type R or BTNRep<K, V, BSTNode<K, V>>. It represents either a key, a node, an entry, or a raw
      * element.
      * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
      * value associated with a key in a key-value pair.
-     * @returns either a NODE object or undefined.
+     * @returns either a BSTNode<K, V> object or undefined.
      */
-    _keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-        const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    _keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value) {
+        const [node, entryValue] = super._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
         if (node === null)
             return [undefined, undefined];
         return [node, value !== null && value !== void 0 ? value : entryValue];
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function sets the root of a tree-like structure and updates the parent property of the new
      * root.
-     * @param {OptNode<NODE>} v - v is a parameter of type NODE or undefined.
+     * @param {OptNode<BSTNode<K, V>>} v - v is a parameter of type BSTNode<K, V> or undefined.
      */
     _setRoot(v) {
         if (v) {
@@ -880,6 +902,20 @@ class BST extends binary_tree_1.BinaryTree {
         }
         this._root = v;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The _compare function compares two values using a specified comparator function and optionally
+     * reverses the result.
+     * @param {K} a - The parameter `a` is of type `K`, which is used as an input for comparison in the
+     * `_compare` method.
+     * @param {K} b - The parameter `b` in the `_compare` function is of type `K`.
+     * @returns The `_compare` method is returning the result of the ternary expression. If `_isReverse`
+     * is true, it returns the negation of the result of calling the `_comparator` function with
+     * arguments `a` and `b`. If `_isReverse` is false, it returns the result of calling the
+     * `_comparator` function with arguments `a` and `b`.
+     */
     _compare(a, b) {
         return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
     }

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

@@ -6,3 +6,5 @@ export * from './avl-tree';
 export * from './red-black-tree';
 export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
+export * from './tree-counter';
+export * from './avl-tree-counter';

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

@@ -22,3 +22,5 @@ __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./red-black-tree"), exports);
 __exportStar(require("./avl-tree-multi-map"), exports);
 __exportStar(require("./tree-multi-map"), exports);
+__exportStar(require("./tree-counter"), exports);
+__exportStar(require("./avl-tree-counter"), exports);