heap-typed 1.49.8 → 1.50.0

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

@@ -56,13 +56,6 @@ export declare class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> =
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeNode class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -70,15 +70,6 @@ class AVLTree extends bst_1.BST {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof AVLTreeNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof AVLTreeNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -135,13 +135,6 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns a boolean value.
      */
     isNodeOrNull(node: KeyOrNodeOrEntry<K, V, N>): node is N | null;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity O(log n) - O(n)
      * Space Complexity O(1)
@@ -344,7 +337,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
      * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
@@ -352,7 +345,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
-    getPathToRoot(beginRoot: KeyOrNodeOrEntry<K, V, N>, isReverse?: boolean): N[];
+    getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, N>, isReverse?: boolean): N[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -409,30 +402,20 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * @returns a boolean value.
      */
     isBST(beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): boolean;
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    subTreeTraverse<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    dfs<C extends BTNCallback<N | null | undefined>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    dfs<C extends BTNCallback<N | null>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
     bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[];
-    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[];
-    bfs<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
+    bfs<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
      */
     listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: false): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: undefined): ReturnType<C>[][];
-    listLevels<C extends BTNCallback<N | null | undefined>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
+    listLevels<C extends BTNCallback<N | null>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType, includeNull?: true): ReturnType<C>[][];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -150,7 +150,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         else if (this.isNode(keyOrNodeOrEntry)) {
             node = keyOrNodeOrEntry;
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value);
         }
         else {
@@ -241,15 +241,6 @@ class BinaryTree extends base_1.IterableEntryBase {
     isNodeOrNull(node) {
         return this.isRealNode(node) || node === null;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof BinaryTreeNode);
-    }
     /**
      * Time Complexity O(log n) - O(n)
      * Space Complexity O(1)
@@ -811,7 +802,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      *
      * The function `getPathToRoot` returns an array of nodes from a given node to the root of a tree
      * structure, with the option to reverse the order of the nodes.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
+     * @param {K | N | null | undefined} beginNode - The `beginRoot` parameter represents the
      * starting node from which you want to find the path to the root. It can be of type `K`, `N`,
      * `null`, or `undefined`.
      * @param [isReverse=true] - The `isReverse` parameter is a boolean flag that determines whether the
@@ -819,19 +810,19 @@ class BinaryTree extends base_1.IterableEntryBase {
      * reversed before returning it. If `isReverse` is set to `false`, the path will be returned as is
      * @returns The function `getPathToRoot` returns an array of nodes (`N[]`).
      */
-    getPathToRoot(beginRoot, isReverse = true) {
+    getPathToRoot(beginNode, isReverse = true) {
         // TODO to support get path through passing key
         const result = [];
-        beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        beginNode = this.ensureNode(beginNode);
+        if (!beginNode)
             return result;
-        while (beginRoot.parent) {
+        while (beginNode.parent) {
             // Array.push + Array.reverse is more efficient than Array.unshift
             // TODO may consider using Deque, so far this is not the performance bottleneck
-            result.push(beginRoot);
-            beginRoot = beginRoot.parent;
+            result.push(beginNode);
+            beginNode = beginNode.parent;
         }
-        result.push(beginRoot);
+        result.push(beginNode);
         return isReverse ? result.reverse() : result;
     }
     /**
@@ -974,68 +965,6 @@ class BinaryTree extends base_1.IterableEntryBase {
             return isStandardBST || isInverseBST;
         }
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     *
-     * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
-     * node, either recursively or iteratively.
-     * @param {C} callback - The `callback` parameter is a function that will be called for each node in
-     * the subtree traversal. It takes a single parameter, which is the current node being traversed, and
-     * returns a value of any type.
-     * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter represents the
-     * starting node or key from which the subtree traversal should begin. It can be of type `K`,
-     * `N`, `null`, or `undefined`. If not provided, the `root` property of the current object is used as
-     * the default value.
-     * @param iterationType - The `iterationType` parameter determines the type of traversal to be
-     * performed on the subtree. It can have two possible values:
-     * @param [includeNull=false] - The `includeNull` parameter is a boolean value that determines
-     * whether to include null values in the traversal. If `includeNull` is set to `true`, the
-     * traversal will include null values, otherwise it will skip them.
-     * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-     * the `callback` function on each node in the subtree. The type of the array nodes is determined
-     * by the return type of the `callback` function.
-     */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-        beginRoot = this.ensureNode(beginRoot);
-        const ans = [];
-        if (!beginRoot)
-            return ans;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const _traverse = (cur) => {
-                if (cur !== undefined) {
-                    ans.push(callback(cur));
-                    if (includeNull) {
-                        cur && this.isNodeOrNull(cur.left) && _traverse(cur.left);
-                        cur && this.isNodeOrNull(cur.right) && _traverse(cur.right);
-                    }
-                    else {
-                        cur && cur.left && _traverse(cur.left);
-                        cur && cur.right && _traverse(cur.right);
-                    }
-                }
-            };
-            _traverse(beginRoot);
-        }
-        else {
-            const stack = [beginRoot];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                if (cur !== undefined) {
-                    ans.push(callback(cur));
-                    if (includeNull) {
-                        cur && this.isNodeOrNull(cur.right) && stack.push(cur.right);
-                        cur && this.isNodeOrNull(cur.left) && stack.push(cur.left);
-                    }
-                    else {
-                        cur && cur.right && stack.push(cur.right);
-                        cur && cur.left && stack.push(cur.left);
-                    }
-                }
-            }
-        }
-        return ans;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { BSTVariant, CP, IterationType } from '../../types';
+import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
@@ -100,13 +100,6 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns either a node object (N) or undefined.
      */
     ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N | undefined;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
@@ -157,25 +150,6 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
     addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): boolean[];
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot?: KeyOrNodeOrEntry<K, V, N>): K | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -225,6 +199,94 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The method returns an array of nodes (`N[]`).
      */
     getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): N[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the depth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * during the depth-first search traversal. It is an optional parameter and if not provided, a
+     * default callback function will be used.
+     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
+     * nodes are visited during the depth-first search. It can have one of the following values:
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
+     * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
+     * value is provided, the DFS traversal will start from the root of the tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
+     * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+     * following values:
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    dfs<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the breadth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the breadth-first search traversal. It is an optional parameter and if not
+     * provided, a default callback function will be used.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
+     * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
+     * the tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
+     * nodes are visited.
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    bfs<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): ReturnType<C>[];
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the listLevels method and returns an array of arrays containing the return
+     * type of the callback function for each level of the tree.
+     * @param {C} callback - The `callback` parameter is a generic type `C` that extends
+     * `BTNCallback<N>`. It represents a callback function that will be called for each node in the tree
+     * during the level listing process.
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
+     * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
+     * provided, the root of the binary tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed on the tree. It determines the order in which the nodes are visited during the
+     * iteration.
+     * @returns The method is returning a two-dimensional array of the return type of the callback
+     * function.
+     */
+    listLevels<C extends BTNCallback<N>>(callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, N>, iterationType?: IterationType): ReturnType<C>[][];
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+     * leftmost node if the comparison result is greater than.
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+     * the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise. If no node is found, it returns 0.
+     */
+    lastKey(beginRoot?: KeyOrNodeOrEntry<K, V, N>): K | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)

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

@@ -127,7 +127,7 @@ class BST extends binary_tree_1.BinaryTree {
                 node = this.createNode(key, value);
             }
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value);
         }
         else {
@@ -167,15 +167,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return res;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof BSTNode);
-    }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
@@ -343,42 +334,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root) {
-        let current = this.ensureNode(beginRoot);
-        if (!current)
-            return undefined;
-        if (this._variant === types_1.BSTVariant.STANDARD) {
-            // For BSTVariant.MIN, find the rightmost node
-            while (current.right !== undefined) {
-                current = current.right;
-            }
-        }
-        else {
-            // For BSTVariant.MAX, find the leftmost node
-            while (current.left !== undefined) {
-                current = current.left;
-            }
-        }
-        return current.key;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -513,6 +468,136 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return ans;
     }
+    // /**
+    //  * The function overrides the subTreeTraverse method and returns the result of calling the super
+    //  * method with the provided arguments.
+    //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+    //  * the subtree traversal. It should accept a single parameter of type `N`, which represents a node in
+    //  * the tree. The return type of the callback function can be any type.
+    //  * @param beginRoot - The `beginRoot` parameter is the starting point for traversing the subtree. It
+    //  * can be either a key, a node, or an entry.
+    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+    //  * be performed during the traversal of the subtree. It can have one of the following values:
+    //  * @returns The method is returning an array of the return type of the callback function.
+    //  */
+    // override subTreeTraverse<C extends BTNCallback<N>>(
+    //   callback: C = this._defaultOneParamCallback as C,
+    //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    //   iterationType = this.iterationType
+    // ): ReturnType<C>[] {
+    //   return super.subTreeTraverse(callback, beginRoot, iterationType, false);
+    // }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the depth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * during the depth-first search traversal. It is an optional parameter and if not provided, a
+     * default callback function will be used.
+     * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
+     * nodes are visited during the depth-first search. It can have one of the following values:
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
+     * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
+     * value is provided, the DFS traversal will start from the root of the tree.
+     * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
+     * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+     * following values:
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
+        return super.dfs(callback, pattern, beginRoot, iterationType, false);
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the breadth-first search method and returns an array of the return types of
+     * the callback function.
+     * @param {C} callback - The `callback` parameter is a function that will be called for each node
+     * visited during the breadth-first search traversal. It is an optional parameter and if not
+     * provided, a default callback function will be used.
+     * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
+     * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
+     * the tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
+     * nodes are visited.
+     * @returns The method is returning an array of the return type of the callback function.
+     */
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+        return super.bfs(callback, beginRoot, iterationType, false);
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function overrides the listLevels method and returns an array of arrays containing the return
+     * type of the callback function for each level of the tree.
+     * @param {C} callback - The `callback` parameter is a generic type `C` that extends
+     * `BTNCallback<N>`. It represents a callback function that will be called for each node in the tree
+     * during the level listing process.
+     * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
+     * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
+     * provided, the root of the binary tree is used as the starting point.
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed on the tree. It determines the order in which the nodes are visited during the
+     * iteration.
+     * @returns The method is returning a two-dimensional array of the return type of the callback
+     * function.
+     */
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
+        return super.listLevels(callback, beginRoot, iterationType, false);
+    }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     *
+     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+     * leftmost node if the comparison result is greater than.
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+     * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+     * the key of the leftmost node if the comparison result is greater than, and the key of the
+     * rightmost node otherwise. If no node is found, it returns 0.
+     */
+    lastKey(beginRoot = this.root) {
+        let current = this.ensureNode(beginRoot);
+        if (!current)
+            return undefined;
+        if (this._variant === types_1.BSTVariant.STANDARD) {
+            // For BSTVariant.MIN, find the rightmost node
+            while (current.right !== undefined) {
+                current = current.right;
+            }
+        }
+        else {
+            // For BSTVariant.MAX, find the leftmost node
+            while (current.left !== undefined) {
+                current = current.left;
+            }
+        }
+        return current.key;
+    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)

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

@@ -79,13 +79,6 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Space Complexity: O(1)
      */
     isRealNode(node: N | undefined): node is N;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -100,7 +100,7 @@ class RedBlackTree extends bst_1.BST {
                 node = this.createNode(key, value, types_1.RBTNColor.RED);
             }
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value, types_1.RBTNColor.RED);
         }
         else {
@@ -126,15 +126,6 @@ class RedBlackTree extends bst_1.BST {
             return false;
         return node instanceof RedBlackTreeNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof RedBlackTreeNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -60,13 +60,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -33,7 +33,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     // TODO the _count is not accurate after nodes count modified
     get count() {
         let sum = 0;
-        this.subTreeTraverse(node => (sum += node.count));
+        this.dfs(node => (sum += node.count));
         return sum;
     }
     /**
@@ -79,7 +79,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
@@ -96,15 +96,6 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof TreeMultimapNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)