undirected-graph-typed 1.54.2 → 1.54.3

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

@@ -1,17 +1,10 @@
-import type {
-  BinaryTreeDeleteResult,
-  BTNRep,
-  CRUD,
-  EntryCallback,
-  OptNode,
-  OptNodeOrNull,
-  RBTNColor,
-  RedBlackTreeOptions
-} from '../../types';
+import type { BinaryTreeDeleteResult, CRUD, EntryCallback, OptNode, RBTNColor, RedBlackTreeOptions } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
 export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
+  override parent?: RedBlackTreeNode<K, V> = undefined;
+
   /**
    * The constructor initializes a node with a key, value, and color for a Red-Black Tree.
    * @param {K} key - The `key` parameter is a key of type `K` that is used to identify the node in a
@@ -27,28 +20,26 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
     this._color = color;
   }
 
-  override parent?: RedBlackTreeNode<K, V> = undefined;
+  override _left?: RedBlackTreeNode<K, V> | null | undefined = undefined;
 
-  override _left?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
-
-  override get left(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+  override get left(): RedBlackTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+  override set left(v: RedBlackTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<RedBlackTreeNode<K, V>> = undefined;
+  override _right?: RedBlackTreeNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<RedBlackTreeNode<K, V>> {
+  override get right(): RedBlackTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<RedBlackTreeNode<K, V>>) {
+  override set right(v: RedBlackTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -60,12 +51,6 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
  * @example
- * // Find elements in a range
- *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
- *     console.log(bst.search(new Range(15, 20))); // [15, 18]
- * @example
  * // using Red-Black Tree as a price-based index for stock data
  *     // Define the structure of individual stock records
  *     interface StockRecord {
@@ -107,7 +92,7 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
  *       [200, 400], // Price range
  *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
  *     );
- *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
+ *     console.log(stocksInRange); // ['GOOGL', 'META', 'MSFT']
  */
 export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends BST<K, V, R, MK, MV, MR>
@@ -117,7 +102,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * This TypeScript constructor initializes a Red-Black Tree with optional keys, nodes, entries, or
    * raw data.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `BTNRep<K, V, RedBlackTreeNode<K, V>>` objects or `R` objects. It
+   * iterable that can contain either `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined` objects or `R` objects. It
    * is used to initialize the Red-Black Tree with keys, nodes, entries, or
    * @param [options] - The `options` parameter in the constructor is of type `RedBlackTreeOptions<K,
    * V, R>`. It is an optional parameter that allows you to specify additional options for the
@@ -125,7 +110,9 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * any other parameters that are specific to
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, RedBlackTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: RedBlackTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -188,12 +175,14 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `RedBlackTreeNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>): keyNodeOrEntry is RedBlackTreeNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is RedBlackTreeNode<K, V> {
     return keyNodeOrEntry instanceof RedBlackTreeNode;
   }
 
@@ -215,8 +204,8 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function adds a new node to a binary search tree and returns true if the node was successfully
    * added.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept a value of type `R` or `BTNRep<K, V, RedBlackTreeNode<K, V>>`.
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept a value of type `R` or `K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
    * the key in the data structure. It represents the value that you want to add or update in the data
    * structure.
@@ -224,7 +213,10 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * the method returns true. If the node already exists and its value is updated, the method also
    * returns true. If the node cannot be added or updated, the method returns false.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (!this.isRealNode(newNode)) return false;
 
@@ -254,7 +246,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function overrides the delete method in a binary tree data structure to remove a node based on
    * a given predicate and maintain the binary search tree properties.
-   * @param {BTNRep<K, V, RedBlackTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override delete` method is used to specify the condition or key based on which a
    * node should be deleted from the binary tree. It can be a key, a node, an entry, or a predicate
    * function that determines which node(s) should be deleted.
@@ -263,7 +255,7 @@ export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR =
    * balancing is needed.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, RedBlackTreeNode<K, V>>
+    keyNodeOrEntry: K | RedBlackTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
   ): BinaryTreeDeleteResult<RedBlackTreeNode<K, V>>[] {
     if (keyNodeOrEntry === null) return [];
 

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

@@ -8,11 +8,9 @@
 import type {
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep,
   EntryCallback,
   IterationType,
   OptNode,
-  OptNodeOrNull,
   RBTNColor,
   TreeCounterOptions
 } from '../../types';
@@ -20,6 +18,8 @@ import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 
 export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
+  override parent?: TreeCounterNode<K, V> = undefined;
+
   /**
    * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
    * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -37,28 +37,26 @@ export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
     this.count = count;
   }
 
-  override parent?: TreeCounterNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<TreeCounterNode<K, V>> = undefined;
+  override _left?: TreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<TreeCounterNode<K, V>> {
+  override get left(): TreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<TreeCounterNode<K, V>>) {
+  override set left(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<TreeCounterNode<K, V>> = undefined;
+  override _right?: TreeCounterNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<TreeCounterNode<K, V>> {
+  override get right(): TreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<TreeCounterNode<K, V>>) {
+  override set right(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -83,7 +81,9 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * `compareValues`, which are functions used to compare keys and values respectively.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, TreeCounterNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: TreeCounterOptions<K, V, R>
   ) {
     super([], options);
@@ -111,7 +111,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    */
   getComputedCount(): number {
     let sum = 0;
-    this.dfs(node => (sum += node.count));
+    this.dfs(node => (sum += node ? node.count : 0));
     return sum;
   }
 
@@ -152,12 +152,14 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
 
   /**
    * The function checks if the input is an instance of the TreeCounterNode class.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `TreeCounterNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>): keyNodeOrEntry is TreeCounterNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is TreeCounterNode<K, V> {
     return keyNodeOrEntry instanceof TreeCounterNode;
   }
 
@@ -167,7 +169,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function overrides the add method of a class and adds a new node to a data structure, updating
    * the count and returning a boolean indicating success.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The
    * `keyNodeOrEntry` parameter can accept one of the following types:
    * @param {V} [value] - The `value` parameter represents the value associated with the key in the
    * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -177,7 +179,11 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The method is returning a boolean value. It returns true if the addition of the new node
    * was successful, and false otherwise.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>, value?: V, count = 1): boolean {
+  override add(
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V,
+    count = 1
+  ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
     const isSuccessAdded = super.add(newNode, newValue);
@@ -196,7 +202,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `delete` in TypeScript overrides the deletion operation in a binary tree data
    * structure, handling cases where nodes have children and maintaining balance in the tree.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The `predicate`
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The `predicate`
    * parameter in the `delete` method is used to specify the condition or key based on which a node
    * should be deleted from the binary tree. It can be a key, a node, or an entry.
    * @param [ignoreCount=false] - The `ignoreCount` parameter in the `override delete` method is a
@@ -206,7 +212,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<TreeCounterNode<K, V>>` objects.
    */
   override delete(
-    keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     ignoreCount = false
   ): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[] {
     if (keyNodeOrEntry === null) return [];
@@ -340,8 +346,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
-        else this.add(midNode.key, midNode.value, midNode.count);
+        if (this._isMapMode && midNode !== null) this.add(midNode.key, undefined, midNode.count);
+        else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -357,8 +363,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
-            else this.add(midNode.key, midNode.value, midNode.count);
+            if (this._isMapMode && midNode !== null) this.add(midNode.key, undefined, midNode.count);
+            else if (midNode !== null) this.add(midNode.key, midNode.value, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -377,7 +383,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    */
   override clone() {
     const cloned = this.createTree();
-    this.bfs(node => cloned.add(node.key, undefined, node.count));
+    this.bfs(node => cloned.add(node === null ? null : node.key, undefined, node === null ? 0 : node.count));
     if (this._isMapMode) cloned._store = this._store;
     return cloned;
   }
@@ -413,8 +419,8 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
   /**
    * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
    * node based on the input.
-   * @param {BTNRep<K, V, TreeCounterNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, TreeCounterNode<K, V>>`.
+   * @param {K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined} keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined`.
    * @param {V} [value] - The `value` parameter is an optional value that represents the value
    * associated with the key in the node. It is used when creating a new node or updating the value of
    * an existing node.
@@ -423,7 +429,7 @@ export class TreeCounter<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns either a TreeCounterNode<K, V> object or undefined.
    */
   protected override _keyValueNodeOrEntryToNodeAndValue(
-    keyNodeOrEntry: BTNRep<K, V, TreeCounterNode<K, V>>,
+    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): [TreeCounterNode<K, V> | undefined, V | undefined] {

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

@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNOptKeyOrNull, BTNRep, OptNodeOrNull, TreeMultiMapOptions } from '../../types';
+import type { BTNOptKeyOrNull, TreeMultiMapOptions } from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
+  override parent?: TreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -23,28 +25,26 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
     super(key, value);
   }
 
-  override parent?: TreeMultiMapNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
+  override _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get left(): TreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set left(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<TreeMultiMapNode<K, V>> = undefined;
+  override _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<TreeMultiMapNode<K, V>> {
+  override get right(): TreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<TreeMultiMapNode<K, V>>) {
+  override set right(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -57,8 +57,8 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
  * @example
  * // Find elements in a range
  *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
+ *     console.log(tmm.search(new Range(5, 10))); // [5, 7, 10]
+ *     console.log(tmm.search(new Range(4, 12))); // [5, 7, 10, 12]
  *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
  */
 export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object>
@@ -77,7 +77,9 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * additional options for configuring the TreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], TreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: TreeMultiMapOptions<K, V[], R>
   ) {
     super([], { ...options, isMapMode: true });
@@ -124,7 +126,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     return new TreeMultiMapNode<K, V>(key, []);
   }
 
-  override add(node: BTNRep<K, V[], TreeMultiMapNode<K, V>>): boolean;
+  override add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -134,7 +136,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
    * TreeMultiMapNode, handling different input types and scenarios.
-   * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
    * of values, and a `TreeMultiMapNode`, or just a key.
    * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
@@ -143,7 +145,10 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `add` method is returning a boolean value, which indicates whether the operation was
    * successful or not.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
@@ -186,7 +191,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    *
    * The function `deleteValue` removes a specific value from a key in a TreeMultiMap data structure
    * and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], TreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object containing a key and an
    * array of values, or just a key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -196,7 +201,10 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * @returns The `deleteValue` function returns a boolean value - `true` if the specified `value` was
    * successfully deleted from the values associated with the `keyNodeOrEntry`, and `false` otherwise.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], TreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);

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

@@ -7,6 +7,7 @@ export type BinaryTreeOptions<K, V, R> = {
   iterationType?: IterationType;
   toEntryFn?: ToEntryFn<K, V, R>;
   isMapMode?: boolean;
+  isDuplicate?: boolean;
 }
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };

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

@@ -2,7 +2,7 @@ import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
 import { OptValue } from '../../common';
 
-export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
+export type BSTOptions<K, V, R> = Omit<BinaryTreeOptions<K, V, R>, 'isDuplicate'> & {
   specifyComparable?: (key: K) => Comparable
   isReverse?: boolean;
 }

package/src/utils/utils.ts

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { Comparable, ComparablePrimitive, Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';