heap-typed 1.52.4 → 1.52.5

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

@@ -25,7 +25,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
      * value associated with the key in the constructor.
      */
     constructor(key: K, value?: V);
-    protected _left?: NODE | null;
+    protected _left?: OptBTNOrNull<NODE>;
     /**
      * The function returns the value of the `_left` property, which can be of type `NODE`, `null`, or
      * `undefined`.
@@ -39,7 +39,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
      * `undefined`.
      */
     set left(v: OptBTNOrNull<NODE>);
-    protected _right?: NODE | null;
+    protected _right?: OptBTNOrNull<NODE>;
     /**
      * The function returns the right node of a binary tree or null if it doesn't exist.
      * @returns The method is returning the value of the `_right` property, which can be a `NODE` object,
@@ -129,10 +129,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * or `undefined`.
      */
     keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): OptBTNOrNull<NODE>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -169,7 +165,7 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value.
      */
-    isNodeOrNull(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
+    isRealNodeOrNull(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): node is NODE | null;
     /**
      * The function checks if a given node is equal to the NIL value.
      * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The parameter `node` can be of type `R` or
@@ -177,6 +173,16 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns a boolean value.
      */
     isNIL(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): boolean;
+    /**
+     * The function `isLeaf` determines whether a given node is a leaf node in a binary tree structure.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter in the `isLeaf` function
+     * can be either a regular node (`R`) or a `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns The `isLeaf` function is checking if the provided node is a leaf node in a binary tree.
+     * If the node is `undefined`, it returns `false`. If the node is `null`, it returns `true`.
+     * Otherwise, it checks if both the left and right children of the node are not real nodes, and
+     * returns `true` if they are not, indicating that the node is a
+     */
+    isLeaf(node: R | BTNKeyOrNodeOrEntry<K, V, NODE>): boolean;
     /**
      * The function checks if the input is an array with two elements, indicating it is a binary tree
      * node entry.
@@ -186,20 +192,17 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      */
     isEntry(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntryOrRawElement is BTNEntry<K, V>;
     /**
-     * The function checks if a given value is a valid key by evaluating its type and value.
-     * @param {any} key - The `key` parameter can be of any type. It is the value that we want to check
-     * if it is a valid key.
-     * @param [isCheckValueOf=true] - The `isCheckValueOf` parameter is a boolean flag that determines
-     * whether the function should check the valueOf() method of an object when the key is of type
-     * 'object'. If `isCheckValueOf` is true, the function will recursively call itself with the value
-     * returned by key.valueOf().
-     * @returns a boolean value.
-     */
-    isKey(key: any, isCheckValueOf?: boolean): key is K;
-    /**
-     * Time Complexity O(n)
+     * Time Complexity O(1)
      * Space Complexity O(1)
+     *
+     * The function `isKey` checks if a given key is comparable.
+     * @param {any} key - The `key` parameter is of type `any`, which means it can be any data type in
+     * TypeScript.
+     * @returns The function `isKey` is checking if the `key` parameter is `null` or if it is comparable.
+     * If the `key` is `null`, the function returns `true`. Otherwise, it returns the result of the
+     * `isComparable` function, which is not provided in the code snippet.
      */
+    isKey(key: any): key is K;
     /**
      * Time Complexity O(n)
      * Space Complexity O(1)
@@ -217,11 +220,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * insertion position cannot be found or if there are duplicate keys.
      */
     add(keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean;
-    /**
-     * Time Complexity: O(k * n)
-     * Space Complexity: O(1)
-     * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
-     */
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -237,11 +235,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * successfully added to the data structure.
      */
     addMany(keysOrNodesOrEntriesOrRawElements: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
-    /**
-     * Time Complexity: O(k * n)
-     * Space Complexity: O(1)
-     * "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-     */
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -263,10 +256,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
     getNode<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     getNode<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
     getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -286,10 +275,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
     has<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<NODE, NODE>>(identifier: OptBTNOrNull<NODE>, callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
     has<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null | undefined, callback: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -297,10 +282,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * Clear the binary tree, removing all nodes.
      */
     clear(): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -309,10 +290,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
     isEmpty(): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -326,10 +303,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns a boolean value.
      */
     isPerfectlyBalanced(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -345,10 +318,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns a boolean value.
      */
     isBST(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -364,10 +333,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns the depth of a node in a tree structure.
      */
     getDepth(dist: R | BTNKeyOrNodeOrEntry<K, V, NODE>, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -382,10 +347,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns the maximum height of the binary tree.
      */
     getHeight(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -403,10 +364,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * binary tree.
      */
     getMinHeight(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): number;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -421,47 +378,51 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns The function `getPathToRoot` returns an array of `NODE` objects.
      */
     getPathToRoot(beginNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>, isReverse?: boolean): NODE[];
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The `getLeftMost` function returns the leftmost node in a binary tree, either using recursive or
-     * iterative traversal.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
-     * starting point for finding the leftmost node in a binary tree. It can be either a root node (`R`),
-     * a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
-     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-     * of iteration to be performed. It can have two possible values:
-     * @returns The function `getLeftMost` returns the leftmost node in a binary tree.
-     */
-    getLeftMost(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `getRightMost` function returns the rightmost node in a binary tree, either recursively or
-     * iteratively.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter represents the
-     * starting point for finding the rightmost node in a binary tree. It can be either a root node
-     * (`R`), a key or node or entry (`BTNKeyOrNodeOrEntry<K, V, NODE>`), or `null` or `undefined`.
-     * @param {IterationType} iterationType - The `iterationType` parameter is used to specify the type
-     * of iteration to be performed when finding the rightmost node in a binary tree. It can have two
+     * The function `getLeftMost` retrieves the leftmost node in a binary tree using either recursive or
+     * tail-recursive iteration.
+     * @param {C} callback - The `callback` parameter is a function that will be called with the leftmost
+     * node of a binary tree or null if the tree is empty. It has a default value of `_DEFAULT_CALLBACK`
+     * if not provided explicitly.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter in the
+     * `getLeftMost` function represents the starting point for finding the leftmost node in a binary
+     * tree. It can be either a reference to the root node of the tree (`R`), or a key, node, or entry in
+     * the binary tree structure (`
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getLeftMost` function
+     * specifies the type of iteration to be used when traversing the binary tree nodes. It can have two
      * possible values:
-     * @returns The function `getRightMost` returns a NODE object, `null`, or `undefined`.
+     * @returns The `getLeftMost` function returns the result of the callback function `C` applied to the
+     * leftmost node in the binary tree starting from the `beginRoot` node. If the `beginRoot` is `NIL`,
+     * it returns the result of the callback function applied to `undefined`. If the `beginRoot` is not a
+     * real node, it returns the result of the callback function applied
      */
-    getRightMost(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): OptBTNOrNull<NODE>;
+    getLeftMost<C extends BTNCallback<OptBTNOrNull<NODE>>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     */
+     *
+     * The function `getRightMost` retrieves the rightmost node in a binary tree using either recursive
+     * or iterative traversal methods.
+     * @param {C} callback - The `callback` parameter is a function that will be called with the result
+     * of the operation. It has a generic type `C` which extends `BTNCallback<OptBTNOrNull<NODE>>`. The
+     * default value for `callback` is `this._DEFAULT_CALLBACK` if it is not provided.
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter in the
+     * `getRightMost` function represents the starting point for finding the rightmost node in a binary
+     * tree. It can be either a reference to the root node of the tree (`this.root`) or a specific key,
+     * node, or entry in the tree. If
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getRightMost`
+     * function specifies the type of iteration to be used when finding the rightmost node in a binary
+     * tree. It can have two possible values:
+     * @returns The `getRightMost` function returns the result of the callback function `C` applied to
+     * the rightmost node in the binary tree. The rightmost node is found either through a recursive
+     * depth-first search (if `iterationType` is 'RECURSIVE') or through an indirect implementation of
+     * iteration using tail recursion optimization. The result of the callback function applied to the
+     * rightmost node is returned
+     */
+    getRightMost<C extends BTNCallback<OptBTNOrNull<NODE>>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -472,10 +433,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns the predecessor node of the given node.
      */
     getPredecessor(node: NODE): NODE;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -486,16 +443,32 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * there is no successor, and `undefined` if the input `x` is not a valid node.
      */
     getSuccessor(x?: K | NODE | null): OptBTNOrNull<NODE>;
-    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
     bfs<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
     bfs<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
-    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
-     */
+     *
+     * The `leaves` function in TypeScript iterates through a binary tree to find and return the leaf
+     * nodes based on a specified callback and iteration type.
+     * @param {C} callback - The `callback` parameter is a function that will be called on each leaf node
+     * in the binary tree. It is a generic type `C` that extends `BTNCallback<NODE | null>`, where `NODE`
+     * represents a node in the binary tree. The default value for `callback` is
+     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} beginRoot - The `beginRoot` parameter in the `leaves`
+     * method is used to specify the starting point for finding and processing the leaves of a binary
+     * tree. It represents the root node of the binary tree or a specific key, node, or entry within the
+     * tree from which the search for leaves should begin
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `leaves` method
+     * specifies the type of iteration to be performed when collecting the leaves of a binary tree. It
+     * can have two possible values:
+     * @returns The `leaves` method returns an array of values that are the result of applying the
+     * provided callback function to the leaf nodes in the binary tree structure.
+     */
+    leaves<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    listLevels<C extends BTNCallback<NODE>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<NODE | null>>(callback?: C, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -516,10 +489,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * callback function `callback`.
      */
     morris<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>): ReturnType<C>[];
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -528,10 +497,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
      */
     clone(): TREE;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -548,10 +513,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * the given predicate function.
      */
     filter(predicate: EntryCallback<K, V | undefined, boolean>, thisArg?: any): TREE;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -568,10 +529,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns The `map` method is returning a new tree object.
      */
     map(callback: EntryCallback<K, V | undefined, V>, thisArg?: any): TREE;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -586,11 +543,9 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns Nothing is being returned. The function has a return type of `void`, which means it does
      * not return any value.
      */
-    print(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
+    print(beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, options?: BinaryTreePrintOptions): string;
+    protected _dfs<C extends BTNCallback<NODE>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): ReturnType<C>[];
+    protected _dfs<C extends BTNCallback<NODE | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: R | BTNKeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType, includeNull?: boolean): ReturnType<C>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -602,10 +557,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns an IterableIterator<[K, V | undefined]>.
      */
     protected _getIterator(node?: OptBTNOrNull<NODE>): IterableIterator<[K, V | undefined]>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -625,10 +576,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      */
     protected _displayAux(node: OptBTNOrNull<NODE>, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _DEFAULT_CALLBACK: (node: OptBTNOrNull<NODE>) => K | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -643,10 +590,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * properties, or `undefined` if either `srcNode` or `destNode` is falsy.
      */
     protected _swapProperties(srcNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>, destNode: R | BTNKeyOrNodeOrEntry<K, V, NODE>): NODE | undefined;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -660,10 +603,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * @returns the newNode.
      */
     protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -674,10 +613,6 @@ export declare class BinaryTree<K = any, V = any, R = BTNEntry<K, V>, NODE exten
      * means that it can accept a value of type `NODE`, `null`, or `undefined`.
      */
     protected _setRoot(v: OptBTNOrNull<NODE>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)