data-structure-typed 1.49.8 → 1.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.49.8",
+  "version": "1.50.0",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

package/src/data-structures/binary-tree/avl-tree.ts

@@ -98,16 +98,6 @@ export class AVLTree<
     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.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof AVLTreeNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

package/src/data-structures/binary-tree/binary-tree.ts

@@ -196,7 +196,7 @@ export class BinaryTree<
       }
     } else if (this.isNode(keyOrNodeOrEntry)) {
       node = keyOrNodeOrEntry;
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
@@ -292,16 +292,6 @@ export class BinaryTree<
     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: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof BinaryTreeNode);
-  }
-
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
@@ -1028,7 +1018,7 @@ export class BinaryTree<
    *
    * 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
@@ -1036,20 +1026,20 @@ export class BinaryTree<
    * 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 = true): N[] {
+  getPathToRoot(beginNode: KeyOrNodeOrEntry<K, V, N>, isReverse = true): N[] {
     // TODO to support get path through passing key
     const result: N[] = [];
-    beginRoot = this.ensureNode(beginRoot);
+    beginNode = this.ensureNode(beginNode);
 
-    if (!beginRoot) return result;
+    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;
   }
 
@@ -1202,99 +1192,94 @@ export class BinaryTree<
     }
   }
 
-  /**
-   * 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>[];
-
-  /**
-   * 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<C extends BTNCallback<N | null | undefined>>(
-    callback: C = this._defaultOneParamCallback as C,
-    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
-    iterationType = this.iterationType,
-    includeNull = false
-  ): ReturnType<C>[] {
-    beginRoot = this.ensureNode(beginRoot);
-
-    const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
-    if (!beginRoot) return ans;
-
-    if (iterationType === IterationType.RECURSIVE) {
-      const _traverse = (cur: N | null | undefined) => {
-        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: (N | null | undefined)[] = [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(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 | null>>(
+  //   callback?: C,
+  //   beginRoot?: KeyOrNodeOrEntry<K, V, N>,
+  //   iterationType?: IterationType,
+  //   includeNull?: true
+  // ): ReturnType<C>[];
+  //
+  // /**
+  //  * 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<C extends BTNCallback<N | null | undefined>>(
+  //   callback: C = this._defaultOneParamCallback as C,
+  //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+  //   iterationType = this.iterationType,
+  //   includeNull = false
+  // ): ReturnType<C>[] {
+  //   console.warn('subTreeTraverse is unnecessary, since the dfs method can substitute it.');
+  //
+  //   beginRoot = this.ensureNode(beginRoot);
+  //
+  //   const ans: (ReturnType<BTNCallback<N>> | null | undefined)[] = [];
+  //   if (!beginRoot) return ans;
+  //
+  //   if (iterationType === IterationType.RECURSIVE) {
+  //     const _traverse = (cur: N | null | undefined) => {
+  //       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: (N | null | undefined)[] = [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;
+  // }
 
   dfs<C extends BTNCallback<N>>(
     callback?: C,
@@ -1304,15 +1289,7 @@ export class BinaryTree<
     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>>(
+  dfs<C extends BTNCallback<N | null>>(
     callback?: C,
     pattern?: DFSOrderPattern,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
@@ -1450,14 +1427,7 @@ export class BinaryTree<
     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>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1485,7 +1455,7 @@ export class BinaryTree<
    * @returns an array of values that are the result of invoking the callback function on each node in
    * the breadth-first traversal of a binary tree.
    */
-  bfs<C extends BTNCallback<N | null | undefined>>(
+  bfs<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1551,14 +1521,7 @@ export class BinaryTree<
     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>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: KeyOrNodeOrEntry<K, V, N>,
     iterationType?: IterationType,
@@ -1586,7 +1549,7 @@ export class BinaryTree<
    * be excluded
    * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
    */
-  listLevels<C extends BTNCallback<N | null | undefined>>(
+  listLevels<C extends BTNCallback<N | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
     iterationType = this.iterationType,
@@ -1597,7 +1560,7 @@ export class BinaryTree<
     if (!beginRoot) return levelsNodes;
 
     if (iterationType === IterationType.RECURSIVE) {
-      const _recursive = (node: N | null | undefined, level: number) => {
+      const _recursive = (node: N | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
         if (includeNull) {
@@ -1611,7 +1574,7 @@ export class BinaryTree<
 
       _recursive(beginRoot, 0);
     } else {
-      const stack: [N | null | undefined, number][] = [[beginRoot, 0]];
+      const stack: [N | null, number][] = [[beginRoot, 0]];
 
       while (stack.length > 0) {
         const head = stack.pop()!;

package/src/data-structures/binary-tree/bst.ts

@@ -13,7 +13,7 @@ import type {
   BTNodePureExemplar,
   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';
 import { Queue } from '../queue';
@@ -171,7 +171,7 @@ export class BST<
       } else {
         node = this.createNode(key, value);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
@@ -212,16 +212,6 @@ export class BST<
     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.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    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>`.
@@ -407,43 +397,6 @@ export class BST<
     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: KeyOrNodeOrEntry<K, V, N> = this.root): K | undefined {
-    let current = this.ensureNode(beginRoot);
-    if (!current) return undefined;
-
-    if (this._variant === 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)
@@ -573,6 +526,157 @@ export class BST<
     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.
+   */
+  override dfs<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    pattern: DFSOrderPattern = 'in',
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType: IterationType = IterationType.ITERATIVE
+  ): ReturnType<C>[] {
+    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.
+   */
+  override bfs<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[] {
+    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.
+   */
+  override listLevels<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[][] {
+    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: KeyOrNodeOrEntry<K, V, N> = this.root): K | undefined {
+    let current = this.ensureNode(beginRoot);
+    if (!current) return undefined;
+
+    if (this._variant === 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/src/data-structures/binary-tree/rb-tree.ts

@@ -132,7 +132,7 @@ export class RedBlackTree<
       } else {
         node = this.createNode(key, value, RBTNColor.RED);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
     } else {
       return;
@@ -160,16 +160,6 @@ export class RedBlackTree<
     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.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof RedBlackTreeNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

package/src/data-structures/binary-tree/tree-multimap.ts

@@ -62,7 +62,7 @@ export class TreeMultimap<
   // TODO the _count is not accurate after nodes count modified
   get count(): number {
     let sum = 0;
-    this.subTreeTraverse(node => (sum += node.count));
+    this.dfs(node => (sum += node.count));
     return sum;
   }
 
@@ -111,7 +111,7 @@ export class TreeMultimap<
       } else {
         node = this.createNode(key, value, count);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value, count);
     } else {
       return;
@@ -129,16 +129,6 @@ export class TreeMultimap<
     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.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof TreeMultimapNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)