priority-queue-typed 1.52.8 → 1.53.0

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

@@ -1,14 +1,12 @@
 import type {
   BinaryTreeDeleteResult,
-  BTNKeyOrNodeOrEntry,
-  BTNPredicate,
+  BTNRep,
   CRUD,
-  OptBSTN,
+  OptNode,
   RBTNColor,
   RBTreeOptions,
   RedBlackTreeNested,
-  RedBlackTreeNodeNested,
-  BTNEntry
+  RedBlackTreeNodeNested
 } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -56,7 +54,7 @@ export class RedBlackTreeNode<
 export class RedBlackTree<
     K = any,
     V = any,
-    R = BTNEntry<K, V>,
+    R = object,
     NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
     TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>
   >
@@ -65,7 +63,7 @@ export class RedBlackTree<
 {
   /**
    * This is the constructor function for a Red-Black Tree data structure in TypeScript.
-   * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+   * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
    * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
    * initialize the RBTree with the provided elements.
    * @param [options] - The `options` parameter is an optional object that can be passed to the
@@ -73,16 +71,13 @@ export class RedBlackTree<
    * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
    * depend on the implementation
    */
-  constructor(
-    keysOrNodesOrEntriesOrRaws: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
-    options?: RBTreeOptions<K, V, R>
-  ) {
+  constructor(keysNodesEntriesOrRaws: Iterable<R | BTNRep<K, V, NODE>> = [], options?: RBTreeOptions<K, V, R>) {
     super([], options);
 
     this._root = this.NIL;
 
-    if (keysOrNodesOrEntriesOrRaws) {
-      this.addMany(keysOrNodesOrEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) {
+      this.addMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -123,6 +118,7 @@ export class RedBlackTree<
   override createTree(options?: RBTreeOptions<K, V, R>): TREE {
     return new RedBlackTree<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
+      isMapMode: this._isMapMode,
       comparator: this._comparator,
       toEntryFn: this._toEntryFn,
       ...options
@@ -134,13 +130,13 @@ export class RedBlackTree<
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of the RedBlackTreeNode class.
-   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-   * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-   * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+   * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
    * an instance of the `RedBlackTreeNode` class.
    */
-  override isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE {
-    return keyOrNodeOrEntryOrRaw instanceof RedBlackTreeNode;
+  override isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE {
+    return keyNodeEntryOrRaw instanceof RedBlackTreeNode;
   }
 
   // /**
@@ -152,29 +148,29 @@ export class RedBlackTree<
   //  * Time Complexity: O(1)
   //  * Space Complexity: O(1)
   //  *
-  //  * The function `keyValueOrEntryOrRawElementToNode` takes a key, value, or entry and returns a node if it is
+  //  * The function `keyValueNodeEntryRawToNodeAndValue` takes a key, value, or entry and returns a node if it is
   //  * valid, otherwise it returns undefined.
-  //  * @param {BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRaw - The key, value, or entry to convert.
-  //  * @param {V} [value] - The value associated with the key (if `keyOrNodeOrEntryOrRaw` is a key).
+  //  * @param {BTNRep<K, V, NODE>} keyNodeEntryOrRaw - The key, value, or entry to convert.
+  //  * @param {V} [value] - The value associated with the key (if `keyNodeEntryOrRaw` is a key).
   //  * @returns {NODE | undefined} - The corresponding Red-Black Tree node, or `undefined` if conversion fails.
   //  */
-  // override keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): NODE | undefined {
+  // override keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): NODE | undefined {
   //
-  //   if (keyOrNodeOrEntryOrRaw === null || keyOrNodeOrEntryOrRaw === undefined) return;
-  //   if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
+  //   if (keyNodeEntryOrRaw === null || keyNodeEntryOrRaw === undefined) return;
+  //   if (this.isNode(keyNodeEntryOrRaw)) return keyNodeEntryOrRaw;
   //
   //   if (this._toEntryFn) {
-  //     const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
-  //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
+  //     const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+  //     if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'RED');
   //   }
   //
-  //   if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-  //     const [key, value] = keyOrNodeOrEntryOrRaw;
+  //   if (this.isEntry(keyNodeEntryOrRaw)) {
+  //     const [key, value] = keyNodeEntryOrRaw;
   //     if (key === undefined || key === null) return;
   //     else return  this.createNode(key, value, 'RED');
   //   }
   //
-  //   if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'RED');
+  //   if (this.isKey(keyNodeEntryOrRaw)) return this.createNode(keyNodeEntryOrRaw, value, 'RED');
   //
   //   return ;
   // }
@@ -197,8 +193,8 @@ export class RedBlackTree<
    *
    * The function adds a new node to a binary search tree and returns true if the node was successfully
    * added.
-   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-   * `keyOrNodeOrEntryOrRaw` can accept a value of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+   * `keyNodeEntryOrRaw` can accept a value of type `R` or `BTNRep<K, V, NODE>`.
    * @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.
@@ -206,8 +202,8 @@ export class RedBlackTree<
    * 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(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V): boolean {
-    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value);
+  override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
+    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (!this.isRealNode(newNode)) return false;
 
     const insertStatus = this._insert(newNode);
@@ -219,6 +215,7 @@ export class RedBlackTree<
       } else {
         return false;
       }
+      if (this._isMapMode) this._setValue(newNode.key, newValue);
       this._size++;
       return true;
     } else return insertStatus === 'UPDATED';
@@ -230,7 +227,7 @@ export class RedBlackTree<
    *
    * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
    * 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.
@@ -238,13 +235,13 @@ export class RedBlackTree<
    * objects. Each object in the array contains information about the deleted node and whether
    * balancing is needed.
    */
-  override delete(predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[] {
-    if (predicate === null) return [];
+  override delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[] {
+    if (keyNodeEntryOrRaw === null) return [];
 
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-    let nodeToDelete: OptBSTN<NODE>;
-    if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-    else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+    let nodeToDelete: OptNode<NODE>;
+    if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+    else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
 
     if (!nodeToDelete) {
       return results;
@@ -285,6 +282,7 @@ export class RedBlackTree<
         successor.color = nodeToDelete.color;
       }
     }
+    if (this._isMapMode) this._store.delete(nodeToDelete.key);
     this._size--;
 
     // If the original color was black, fix the tree

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

@@ -7,16 +7,14 @@
  */
 import type {
   BinaryTreeDeleteResult,
-  BSTNKeyOrNode,
-  BTNKeyOrNodeOrEntry,
-  BTNPredicate,
+  BSTNOptKeyOrNode,
+  BTNRep,
   IterationType,
-  OptBSTN,
+  OptNode,
   RBTNColor,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
-  TreeMultiMapOptions,
-  BTNEntry
+  TreeMultiMapOptions
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
@@ -66,7 +64,7 @@ export class TreeMultiMapNode<
 export class TreeMultiMap<
     K = any,
     V = any,
-    R = BTNEntry<K, V>,
+    R = object,
     NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>,
     TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>
   >
@@ -75,19 +73,16 @@ export class TreeMultiMap<
 {
   /**
    * The constructor function initializes a TreeMultiMap object with optional initial data.
-   * @param keysOrNodesOrEntriesOrRaws - The parameter `keysOrNodesOrEntriesOrRaws` is an
+   * @param keysNodesEntriesOrRaws - The parameter `keysNodesEntriesOrRaws` is an
    * iterable that can contain keys, nodes, entries, or raw elements. It is used to initialize the
    * TreeMultiMap with initial data.
    * @param [options] - The `options` parameter is an optional object that can be used to customize the
    * behavior of the `TreeMultiMap` constructor. It can include properties such as `compareKeys` and
    * `compareValues`, which are functions used to compare keys and values respectively.
    */
-  constructor(
-    keysOrNodesOrEntriesOrRaws: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>> = [],
-    options?: TreeMultiMapOptions<K, V, R>
-  ) {
+  constructor(keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, NODE>> = [], options?: TreeMultiMapOptions<K, V, R>) {
     super([], options);
-    if (keysOrNodesOrEntriesOrRaws) this.addMany(keysOrNodesOrEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -143,6 +138,7 @@ export class TreeMultiMap<
   override createTree(options?: TreeMultiMapOptions<K, V, R>): TREE {
     return new TreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
+      isMapMode: this._isMapMode,
       comparator: this._comparator,
       toEntryFn: this._toEntryFn,
       ...options
@@ -150,10 +146,10 @@ export class TreeMultiMap<
   }
 
   /**
-   * The function `keyValueOrEntryOrRawElementToNode` takes in a key, value, and count and returns a
+   * The function `keyValueNodeEntryRawToNodeAndValue` takes in a key, value, and count and returns a
    * node based on the input.
-   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-   * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
    * @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.
@@ -161,40 +157,42 @@ export class TreeMultiMap<
    * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
    * @returns either a NODE object or undefined.
    */
-  override keyValueOrEntryOrRawElementToNode(
-    keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R,
+  override keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V,
     count = 1
-  ): NODE | undefined {
-    if (keyOrNodeOrEntryOrRaw === undefined || keyOrNodeOrEntryOrRaw === null) return;
+  ): [NODE | undefined, V | undefined] {
+    if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null) return [undefined, undefined];
 
-    if (this.isNode(keyOrNodeOrEntryOrRaw)) return keyOrNodeOrEntryOrRaw;
+    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
 
-    if (this.isEntry(keyOrNodeOrEntryOrRaw)) {
-      const [key, entryValue] = keyOrNodeOrEntryOrRaw;
-      if (key === undefined || key === null) return;
-      if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
+    if (this.isEntry(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = keyNodeEntryOrRaw;
+      if (key === undefined || key === null) return [undefined, undefined];
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
     if (this._toEntryFn) {
-      const [key, entryValue] = this._toEntryFn(keyOrNodeOrEntryOrRaw as R);
-      if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
+      const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    if (this.isKey(keyOrNodeOrEntryOrRaw)) return this.createNode(keyOrNodeOrEntryOrRaw, value, 'BLACK', count);
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, 'BLACK', count), value];
 
-    return;
+    return [undefined, undefined];
   }
 
   /**
    * The function checks if the input is an instance of the TreeMultiMapNode class.
-   * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-   * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-   * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+   * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+   * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
    * an instance of the `TreeMultiMapNode` class.
    */
-  override isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE {
-    return keyOrNodeOrEntryOrRaw instanceof TreeMultiMapNode;
+  override isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE {
+    return keyNodeEntryOrRaw instanceof TreeMultiMapNode;
   }
 
   /**
@@ -203,8 +201,8 @@ export class TreeMultiMap<
    *
    * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-   * `keyOrNodeOrEntryOrRaw` parameter can accept one of the following types:
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+   * `keyNodeEntryOrRaw` 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.
    * @param [count=1] - The `count` parameter represents the number of times the key-value pair should
@@ -213,10 +211,10 @@ export class TreeMultiMap<
    * @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(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count = 1): boolean {
-    const newNode = this.keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw, value, count);
+  override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count = 1): boolean {
+    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
     const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.add(newNode);
+    const isSuccessAdded = super.add(newNode, newValue);
 
     if (isSuccessAdded) {
       this._count += orgCount;
@@ -232,27 +230,23 @@ export class TreeMultiMap<
    *
    * 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 {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - 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, an entry, or a predicate
-   * function.
+   * 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
    * boolean flag that determines whether to ignore the count of nodes when performing deletion. If
    * `ignoreCount` is set to `true`, the method will delete the node regardless of its count. If
    * `ignoreCount` is `false
    * @returns The `override delete` method returns an array of `BinaryTreeDeleteResult<NODE>` objects.
    */
-  override delete(
-    predicate: BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>,
-    ignoreCount = false
-  ): BinaryTreeDeleteResult<NODE>[] {
-    if (predicate === null) return [];
+  override delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, ignoreCount = false): BinaryTreeDeleteResult<NODE>[] {
+    if (keyNodeEntryOrRaw === null) return [];
 
     const results: BinaryTreeDeleteResult<NODE>[] = [];
 
-    let nodeToDelete: OptBSTN<NODE>;
-    if (this._isPredicated(predicate)) nodeToDelete = this.getNode(predicate);
-    else nodeToDelete = this.isRealNode(predicate) ? predicate : this.getNode(predicate);
+    let nodeToDelete: OptNode<NODE>;
+    if (this._isPredicate(keyNodeEntryOrRaw)) nodeToDelete = this.getNode(keyNodeEntryOrRaw);
+    else nodeToDelete = this.isRealNode(keyNodeEntryOrRaw) ? keyNodeEntryOrRaw : this.getNode(keyNodeEntryOrRaw);
 
     if (!nodeToDelete) {
       return results;
@@ -373,7 +367,8 @@ export class TreeMultiMap<
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.value, midNode.count);
+        if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
+        else this.add(midNode.key, midNode.value, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -389,7 +384,8 @@ export class TreeMultiMap<
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.key, midNode.value, midNode.count);
+            if (this._isMapMode) this.add(midNode.key, undefined, midNode.count);
+            else this.add(midNode.key, midNode.value, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -408,7 +404,8 @@ export class TreeMultiMap<
    */
   override clone(): TREE {
     const cloned = this.createTree();
-    this.bfs(node => cloned.add(node.key, node.value, node.count));
+    this.bfs(node => cloned.add(node.key, undefined, node.count));
+    if (this._isMapMode) cloned._store = this._store;
     return cloned;
   }
 
@@ -418,17 +415,17 @@ export class TreeMultiMap<
    *
    * The `_swapProperties` function swaps the properties (key, value, count, color) between two nodes
    * in a binary search tree.
-   * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+   * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
    * that will be swapped with the `destNode`. It can be either an instance of the `R` class or an
-   * instance of the `BSTNKeyOrNode<K, NODE>` class.
-   * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+   * instance of the `BSTNOptKeyOrNode<K, NODE>` class.
+   * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
    * node where the properties will be swapped with the source node.
    * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
    * If either `srcNode` or `destNode` is undefined, it returns undefined.
    */
   protected override _swapProperties(
-    srcNode: R | BSTNKeyOrNode<K, NODE>,
-    destNode: R | BSTNKeyOrNode<K, NODE>
+    srcNode: R | BSTNOptKeyOrNode<K, NODE>,
+    destNode: R | BSTNOptKeyOrNode<K, NODE>
   ): NODE | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
@@ -439,12 +436,12 @@ export class TreeMultiMap<
         tempNode.color = color;
 
         destNode.key = srcNode.key;
-        destNode.value = srcNode.value;
+        if (!this._isMapMode) destNode.value = srcNode.value;
         destNode.count = srcNode.count;
         destNode.color = srcNode.color;
 
         srcNode.key = tempNode.key;
-        srcNode.value = tempNode.value;
+        if (!this._isMapMode) srcNode.value = tempNode.value;
         srcNode.count = tempNode.count;
         srcNode.color = tempNode.color;
       }

package/src/data-structures/trie/trie.ts

@@ -266,9 +266,9 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
    *
    */
   getHeight(): number {
-    const beginRoot = this.root;
+    const startNode = this.root;
     let maxDepth = 0;
-    if (beginRoot) {
+    if (startNode) {
       const bfs = (node: TrieNode, level: number) => {
         if (level > maxDepth) {
           maxDepth = level;
@@ -280,7 +280,7 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
           }
         }
       };
-      bfs(beginRoot, 0);
+      bfs(startNode, 0);
     }
     return maxDepth;
   }

package/src/interfaces/binary-tree.ts

@@ -4,14 +4,14 @@ import type {
   BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
-  BTNKeyOrNodeOrEntry,
-  BTNPredicate
+  BTNRep,
+  NodePredicate
 } from '../types';
 
 export interface IBinaryTree<
   K = any,
   V = any,
-  R = [K, V],
+  R = object,
   NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>,
   TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTreeNested<K, V, R, NODE>
 > {
@@ -19,9 +19,9 @@ export interface IBinaryTree<
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
 
-  add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, NODE>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
 
-  delete(predicate: R | BTNKeyOrNodeOrEntry<K, V, NODE> | BTNPredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+  delete(predicate: R | BTNRep<K, V, NODE> | NodePredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
 }

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

@@ -6,31 +6,30 @@ export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K,
 
 export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
+export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
+
 export type BinaryTreeOptions<K, V, R> = {
-  iterationType?: IterationType;
-  toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+    iterationType?: IterationType;
+    toEntryFn?: ToEntryFn<K, V, R>;
+    isMapMode?: boolean;
 }
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
 
-export type OptBTNOrNull<NODE> = NODE | null | undefined;
-
-export type OptBTNKeyOrNull<K> = K | null | undefined;
-
-export type BTNEntry<K, V> = [OptBTNKeyOrNull<K>, OptValue<V>];
+export type OptNodeOrNull<NODE> = NODE | null | undefined;
 
-export type BTNKeyOrNode<K, NODE> = OptBTNKeyOrNull<K> | NODE;
+export type BTNOptKeyOrNull<K> = K | null | undefined;
 
-export type BTNKeyOrNodeOrEntry<K, V, NODE> = BTNEntry<K, V> | BTNKeyOrNode<K, NODE>;
+export type BTNEntry<K, V> = [BTNOptKeyOrNull<K>, OptValue<V>];
 
-export type BTNPureKeyOrNode<K, NODE> = K | NODE;
+export type BTNOptKeyNodeOrNull<K, NODE> = BTNOptKeyOrNull<K> | NODE;
 
-export type BTNPureKeyOrNodeOrEntry<K, V, NODE> = [K, OptValue<V>] | BTNPureKeyOrNode<K, NODE>;
+export type BTNRep<K, V, NODE> = BTNEntry<K, V> | BTNOptKeyNodeOrNull<K, NODE>;
 
-export type BinaryTreeDeleteResult<NODE> = { deleted: OptBTNOrNull<NODE>; needBalanced: OptBTNOrNull<NODE> };
+export type BinaryTreeDeleteResult<NODE> = { deleted: OptNodeOrNull<NODE>; needBalanced: OptNodeOrNull<NODE> };
 
-export type BTNCallback<NODE, D = any> = (node: NODE) => D;
+export type NodeCallback<NODE, D = any> = (node: NODE) => D;
 
-export type BTNPredicate<NODE> = (node: NODE) => boolean;
+export type NodePredicate<NODE> = (node: NODE) => boolean;
 
-export type DFSStackItem<NODE> = { opt: DFSOperation; node: OptBTNOrNull<NODE> }
+export type DFSStackItem<NODE> = { opt: DFSOperation; node: OptNodeOrNull<NODE> }

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

@@ -7,12 +7,12 @@ export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTN
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-  comparator?: Comparator<K>
+    comparator?: Comparator<K>
 }
 
-export type OptBSTNKey<K> = K | undefined;
+export type BSTNOptKey<K> = K | undefined;
 
-export type OptBSTN<NODE> = NODE | undefined;
+export type OptNode<NODE> = NODE | undefined;
 
-export type BSTNKeyOrNode<K, NODE> = OptBSTNKey<K> | NODE;
+export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;