data-structure-typed 1.50.1 → 1.50.3

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

@@ -6,17 +6,118 @@
  * @license MIT License
  */
 export class SegmentTreeNode {
-    start = 0;
-    end = 0;
-    value = undefined;
-    sum = 0;
-    left = undefined;
-    right = undefined;
+    /**
+     * The constructor initializes the properties of a SegmentTreeNode object.
+     * @param {number} start - The `start` parameter represents the starting index of the segment covered
+     * by this node in a segment tree.
+     * @param {number} end - The `end` parameter represents the end index of the segment covered by this
+     * node in a segment tree.
+     * @param {number} sum - The `sum` parameter represents the sum of the values in the range covered by
+     * the segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} [value] - The `value` parameter is an optional parameter
+     * of type `SegmentTreeNodeVal`. It represents the value associated with the segment tree node.
+     */
     constructor(start, end, sum, value) {
-        this.start = start;
-        this.end = end;
-        this.sum = sum;
-        this.value = value || undefined;
+        this._start = start;
+        this._end = end;
+        this._sum = sum;
+        this._value = value || undefined;
+    }
+    _start = 0;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
+    get start() {
+        return this._start;
+    }
+    /**
+     * The above function sets the value of the "start" property.
+     * @param {number} value - The value parameter is of type number.
+     */
+    set start(value) {
+        this._start = value;
+    }
+    _end = 0;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
+    get end() {
+        return this._end;
+    }
+    /**
+     * The above function sets the value of the "end" property.
+     * @param {number} value - The value parameter is a number that represents the new value for the end
+     * property.
+     */
+    set end(value) {
+        this._end = value;
+    }
+    _value = undefined;
+    /**
+     * The function returns the value of a segment tree node.
+     * @returns The value being returned is either a `SegmentTreeNodeVal` object or `undefined`.
+     */
+    get value() {
+        return this._value;
+    }
+    /**
+     * The function sets the value of a segment tree node.
+     * @param {SegmentTreeNodeVal | undefined} value - The `value` parameter is of type
+     * `SegmentTreeNodeVal` or `undefined`.
+     */
+    set value(value) {
+        this._value = value;
+    }
+    _sum = 0;
+    /**
+     * The function returns the value of the sum property.
+     * @returns The method is returning the value of the variable `_sum`.
+     */
+    get sum() {
+        return this._sum;
+    }
+    /**
+     * The above function sets the value of the sum property.
+     * @param {number} value - The parameter "value" is of type "number".
+     */
+    set sum(value) {
+        this._sum = value;
+    }
+    _left = undefined;
+    /**
+     * The function returns the left child of a segment tree node.
+     * @returns The `left` property of the `SegmentTreeNode` object is being returned. It is of type
+     * `SegmentTreeNode` or `undefined`.
+     */
+    get left() {
+        return this._left;
+    }
+    /**
+     * The function sets the value of the left property of a SegmentTreeNode object.
+     * @param {SegmentTreeNode | undefined} value - The value parameter is of type SegmentTreeNode or
+     * undefined.
+     */
+    set left(value) {
+        this._left = value;
+    }
+    _right = undefined;
+    /**
+     * The function returns the right child of a segment tree node.
+     * @returns The `getRight()` method is returning a value of type `SegmentTreeNode` or `undefined`.
+     */
+    get right() {
+        return this._right;
+    }
+    /**
+     * The function sets the right child of a segment tree node.
+     * @param {SegmentTreeNode | undefined} value - The `value` parameter is of type `SegmentTreeNode |
+     * undefined`. This means that it can accept either a `SegmentTreeNode` object or `undefined` as its
+     * value.
+     */
+    set right(value) {
+        this._right = value;
     }
 }
 export class SegmentTree {
@@ -44,18 +145,34 @@ export class SegmentTree {
         }
     }
     _values = [];
+    /**
+     * The function returns an array of numbers.
+     * @returns An array of numbers is being returned.
+     */
     get values() {
         return this._values;
     }
     _start = 0;
+    /**
+     * The function returns the value of the protected variable _start.
+     * @returns The start value, which is of type number.
+     */
     get start() {
         return this._start;
     }
     _end;
+    /**
+     * The function returns the value of the protected variable `_end`.
+     * @returns The value of the protected property `_end`.
+     */
     get end() {
         return this._end;
     }
     _root;
+    /**
+     * The function returns the root node of a segment tree.
+     * @returns The `root` property of the class `SegmentTreeNode` or `undefined` if it is not defined.
+     */
     get root() {
         return this._root;
     }

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

@@ -9,8 +9,7 @@ import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEnt
 import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
-    count: number;
+export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -22,48 +21,73 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
     constructor(key: K, value?: V, count?: number);
+    protected _count: number;
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count(): number;
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value: number);
 }
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: TreeMultimapOptions<K>);
-    private _count;
+export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, NODE, TREE> = TreeMultimap<K, V, NODE, TreeMultimapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultimapOptions<K>);
+    protected _count: number;
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key: K, value?: V, count?: number): N;
+    createNode(key: K, value?: V, count?: number): NODE;
+    /**
+     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
      * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `N` or `undefined`.
+     * @returns a node of type `NODE` or `undefined`.
      */
-    exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): N | undefined;
+    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n)
@@ -81,47 +105,13 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method is returning either the newly inserted node or `undefined` if the insertion
      * was not successful.
      */
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
-     * structure.
-     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
-     * either keys, nodes, or entries.
-     * @returns The method is returning an array of type `N | undefined`.
-     */
-    addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>): boolean[];
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
-     */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
@@ -137,9 +127,9 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -151,6 +141,22 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -165,13 +171,21 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
     clone(): TREE;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
-    protected _replaceNode(oldNode: N, newNode: N): N;
+    protected _swapProperties(srcNode: BSTNKeyOrNode<K, NODE>, destNode: BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
+    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

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

@@ -1,7 +1,6 @@
 import { FamilyPosition, IterationType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultimapNode extends AVLTreeNode {
-    count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -16,6 +15,22 @@ export class TreeMultimapNode extends AVLTreeNode {
         super(key, value);
         this.count = count;
     }
+    _count = 1;
+    /**
+     * The function returns the value of the protected variable _count.
+     * @returns The count property of the object, which is of type number.
+     */
+    get count() {
+        return this._count;
+    }
+    /**
+     * The above function sets the value of the count property.
+     * @param {number} value - The value parameter is of type number, which means it can accept any
+     * numeric value.
+     */
+    set count(value) {
+        this._count = value;
+    }
 }
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -28,6 +43,11 @@ export class TreeMultimap extends AVLTree {
     }
     _count = 0;
     // TODO the _count is not accurate after nodes count modified
+    /**
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
     get count() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
@@ -37,7 +57,7 @@ export class TreeMultimap extends AVLTree {
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
@@ -45,6 +65,15 @@ export class TreeMultimap extends AVLTree {
     createNode(key, value, count) {
         return new TreeMultimapNode(key, value, count);
     }
+    /**
+     * The function creates a new TreeMultimap object with the specified options and returns it.
+     * @param [options] - The `options` parameter is an optional object that contains additional
+     * configuration options for creating the `TreeMultimap` object. It can include properties such as
+     * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+     * the tree, respectively. These properties can be
+     * @returns a new instance of the `TreeMultimap` class, with the provided options merged with the
+     * default options. The returned value is casted as `TREE`.
+     */
     createTree(options) {
         return new TreeMultimap([], {
             iterationType: this.iterationType,
@@ -53,17 +82,17 @@ export class TreeMultimap extends AVLTree {
         });
     }
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
      * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `N` or `undefined`.
+     * @returns a node of type `NODE` or `undefined`.
      */
-    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
         if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
@@ -90,7 +119,7 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
      * class.
      */
@@ -100,7 +129,6 @@ export class TreeMultimap extends AVLTree {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n)
@@ -119,7 +147,7 @@ export class TreeMultimap extends AVLTree {
      * was not successful.
      */
     add(keyOrNodeOrEntry, value, count = 1) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
             return false;
         const orgNodeCount = newNode?.count || 0;
@@ -130,82 +158,11 @@ export class TreeMultimap extends AVLTree {
         return true;
     }
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
-     * structure.
-     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
-     * either keys, nodes, or entries.
-     * @returns The method is returning an array of type `N | undefined`.
-     */
-    addMany(keysOrNodesOrEntries) {
-        return super.addMany(keysOrNodesOrEntries);
-    }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
-     */
-    perfectlyBalance(iterationType = this.iterationType) {
-        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
-        if (sorted.length < 1)
-            return false;
-        this.clear();
-        if (iterationType === IterationType.RECURSIVE) {
-            const buildBalanceBST = (l, r) => {
-                if (l > r)
-                    return;
-                const m = l + Math.floor((r - l) / 2);
-                const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
-                buildBalanceBST(l, m - 1);
-                buildBalanceBST(m + 1, r);
-            };
-            buildBalanceBST(0, n - 1);
-            return true;
-        }
-        else {
-            const stack = [[0, n - 1]];
-            while (stack.length > 0) {
-                const popped = stack.pop();
-                if (popped) {
-                    const [l, r] = popped;
-                    if (l <= r) {
-                        const m = l + Math.floor((r - l) / 2);
-                        const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
-                        stack.push([m + 1, r]);
-                        stack.push([l, m - 1]);
-                    }
-                }
-            }
-            return true;
-        }
-    }
-    /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
@@ -221,7 +178,7 @@ export class TreeMultimap extends AVLTree {
      * being deleted. If set to true, the count of the node will not be considered and the node will be
      * deleted regardless of its count. If set to false (default), the count of the node will be
      * decremented by 1 and
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         const deletedResult = [];
@@ -294,6 +251,57 @@ export class TreeMultimap extends AVLTree {
         super.clear();
         this._count = 0;
     }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        if (sorted.length < 1)
+            return false;
+        this.clear();
+        if (iterationType === IterationType.RECURSIVE) {
+            const buildBalanceBST = (l, r) => {
+                if (l > r)
+                    return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.key, midNode.value, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.key, midNode.value, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
+                }
+            }
+            return true;
+        }
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -312,9 +320,9 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
@@ -340,6 +348,14 @@ export class TreeMultimap extends AVLTree {
         }
         return undefined;
     }
+    /**
+     * The function replaces an old node with a new node and updates the count property of the new node.
+     * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+     * needs to be replaced in a data structure.
+     * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, after updating the `count` property of the `newNode` object.
+     */
     _replaceNode(oldNode, newNode) {
         newNode.count = oldNode.count + newNode.count;
         return super._replaceNode(oldNode, newNode);