linked-list-typed 1.50.8 → 1.51.0

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

@@ -210,7 +210,10 @@ export class BST<
    * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
    * @returns either a node object (NODE) or undefined.
    */
-  override ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType = 'ITERATIVE'): NODE | undefined {
+  override ensureNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    iterationType: IterationType = 'ITERATIVE'
+  ): NODE | undefined {
     let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -321,7 +324,7 @@ export class BST<
     keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>,
     values?: Iterable<V | undefined>,
     isBalanceAdd = true,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): boolean[] {
     const inserted: boolean[] = [];
 
@@ -422,7 +425,8 @@ export class BST<
    * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
-  override getNodeByKey(key: K, iterationType = 'ITERATIVE'): NODE | undefined {
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+    // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
     if (!this.isRealNode(this.root)) return undefined;
     if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
@@ -480,7 +484,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
@@ -565,7 +569,7 @@ export class BST<
    */
   override dfs<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE'
   ): ReturnType<C>[] {
@@ -597,7 +601,7 @@ export class BST<
   override bfs<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     return super.bfs(callback, beginRoot, iterationType, false);
   }
@@ -628,7 +632,7 @@ export class BST<
   override listLevels<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
     return super.listLevels(callback, beginRoot, iterationType, false);
   }
@@ -699,7 +703,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     targetNode = this.ensureNode(targetNode);
     const ans: ReturnType<BTNCallback<NODE>>[] = [];
@@ -751,8 +755,8 @@ export class BST<
    * values:
    * @returns The function `perfectlyBalance` returns a boolean value.
    */
-  perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     this.clear();
 
@@ -812,7 +816,7 @@ export class BST<
    * to check if the AVL tree is balanced. It can have two possible values:
    * @returns a boolean value.
    */
-  isAVLBalanced(iterationType = this.iterationType): boolean {
+  isAVLBalanced(iterationType: IterationType = this.iterationType): boolean {
     if (!this.root) return true;
 
     let balanced = true;
@@ -884,6 +888,15 @@ export class BST<
     return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
   }
 
+  /**
+   * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
+   * `a` is less than `b` based on the specified variant.
+   * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
+   * first value to be compared in the function.
+   * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
+   * of the arguments for the comparison in the `_lt` function.
+   * @returns a boolean value.
+   */
   protected _lt(a: K, b: K): boolean {
     const extractedA = this.extractor(a);
     const extractedB = this.extractor(b);
@@ -893,6 +906,14 @@ export class BST<
     // return a < b;
   }
 
+  /**
+   * The function compares two values using a custom extractor function and returns true if the first
+   * value is greater than the second value.
+   * @param {K} a - The parameter "a" is of type K, which means it can be any type.
+   * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
+   * of the arguments for the comparison in the function.
+   * @returns a boolean value.
+   */
   protected _gt(a: K, b: K): boolean {
     const extractedA = this.extractor(a);
     const extractedB = this.extractor(b);

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

@@ -2,6 +2,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry,
   RBTreeOptions,
   RedBlackTreeNested,
@@ -25,9 +26,9 @@ export class RedBlackTreeNode<
    * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
    * creating a new instance of the Red-Black Tree Node.
    * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-   * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+   * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
    */
-  constructor(key: K, value?: V, color: RBTNColor = RBTNColor.BLACK) {
+  constructor(key: K, value?: V, color: RBTNColor = 'BLACK') {
     super(key, value);
     this._color = color;
   }
@@ -106,12 +107,12 @@ export class RedBlackTree<
    * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
    * associated with the key in the node. It is not required and can be omitted if not needed.
    * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
-   * Red-Black Tree. It is an optional parameter with a default value of "RBTNColor.BLACK". The color
-   * can be either "RBTNColor.RED" or "RBTNColor.BLACK".
+   * Red-Black Tree. It is an optional parameter with a default value of "'BLACK'". The color
+   * can be either "'RED'" or "'BLACK'".
    * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
    * value, and color.
    */
-  override createNode(key: K, value?: V, color: RBTNColor = RBTNColor.BLACK): NODE {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): NODE {
     return new RedBlackTreeNode<K, V, NODE>(key, value, color) as NODE;
   }
 
@@ -156,10 +157,10 @@ export class RedBlackTree<
       if (key === undefined || key === null) {
         return;
       } else {
-        node = this.createNode(key, value, RBTNColor.RED);
+        node = this.createNode(key, value, 'RED');
       }
     } else if (!this.isNode(keyOrNodeOrEntry)) {
-      node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
+      node = this.createNode(keyOrNodeOrEntry, value, 'RED');
     } else {
       return;
     }
@@ -232,9 +233,8 @@ export class RedBlackTree<
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
-    // if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
@@ -282,7 +282,7 @@ export class RedBlackTree<
     if (insertStatus === 'CREATED') {
       // Ensure the root is black
       if (this.isRealNode(this._root)) {
-        this._root.color = RBTNColor.BLACK;
+        this._root.color = 'BLACK';
       } else {
         return false;
       }
@@ -363,7 +363,7 @@ export class RedBlackTree<
     this._size--;
 
     // If the original color was black, fix the tree
-    if (originalColor === RBTNColor.BLACK) {
+    if (originalColor === 'BLACK') {
       this._deleteFixup(replacementNode);
     }
 
@@ -451,7 +451,7 @@ export class RedBlackTree<
 
     node.left = this.SENTINEL;
     node.right = this.SENTINEL;
-    node.color = RBTNColor.RED;
+    node.color = 'RED';
 
     this._insertFixup(node);
     return 'CREATED';
@@ -500,16 +500,16 @@ export class RedBlackTree<
    */
   protected _insertFixup(z: NODE | undefined): void {
     // Continue fixing the tree as long as the parent of z is red
-    while (z?.parent?.color === RBTNColor.RED) {
+    while (z?.parent?.color === 'RED') {
       // Check if the parent of z is the left child of its parent
       if (z.parent === z.parent.parent?.left) {
         // Case 1: The uncle (y) of z is red
         const y = z.parent.parent.right;
-        if (y?.color === RBTNColor.RED) {
+        if (y?.color === 'RED') {
           // Set colors to restore properties of Red-Black Tree
-          z.parent.color = RBTNColor.BLACK;
-          y.color = RBTNColor.BLACK;
-          z.parent.parent.color = RBTNColor.RED;
+          z.parent.color = 'BLACK';
+          y.color = 'BLACK';
+          z.parent.parent.color = 'RED';
           // Move up the tree to continue fixing
           z = z.parent.parent;
         } else {
@@ -523,8 +523,8 @@ export class RedBlackTree<
           // Case 3: The uncle (y) of z is black, and z is a left child
           // Adjust colors and perform a right rotation
           if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = RBTNColor.BLACK;
-            z.parent.parent.color = RBTNColor.RED;
+            z.parent.color = 'BLACK';
+            z.parent.parent.color = 'RED';
             this._rightRotate(z.parent.parent);
           }
         }
@@ -532,10 +532,10 @@ export class RedBlackTree<
         // Symmetric case for the right child (left and right exchanged)
         // Follow the same logic as above with left and right exchanged
         const y: NODE | undefined = z?.parent?.parent?.left;
-        if (y?.color === RBTNColor.RED) {
-          z.parent.color = RBTNColor.BLACK;
-          y.color = RBTNColor.BLACK;
-          z.parent.parent!.color = RBTNColor.RED;
+        if (y?.color === 'RED') {
+          z.parent.color = 'BLACK';
+          y.color = 'BLACK';
+          z.parent.parent!.color = 'RED';
           z = z.parent.parent;
         } else {
           if (z === z.parent.left) {
@@ -544,8 +544,8 @@ export class RedBlackTree<
           }
 
           if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = RBTNColor.BLACK;
-            z.parent.parent.color = RBTNColor.RED;
+            z.parent.color = 'BLACK';
+            z.parent.parent.color = 'RED';
             this._leftRotate(z.parent.parent);
           }
         }
@@ -553,7 +553,7 @@ export class RedBlackTree<
     }
 
     // Ensure that the root is black after fixing
-    if (this.isRealNode(this._root)) this._root.color = RBTNColor.BLACK;
+    if (this.isRealNode(this._root)) this._root.color = 'BLACK';
   }
 
   /**
@@ -573,14 +573,14 @@ export class RedBlackTree<
    */
   protected _deleteFixup(node: NODE | undefined): void {
     // Early exit condition
-    if (!node || node === this.root || node.color === RBTNColor.BLACK) {
+    if (!node || node === this.root || node.color === 'BLACK') {
       if (node) {
-        node.color = RBTNColor.BLACK; // Ensure the final node is black
+        node.color = 'BLACK'; // Ensure the final node is black
       }
       return;
     }
 
-    while (node && node !== this.root && node.color === RBTNColor.BLACK) {
+    while (node && node !== this.root && node.color === 'BLACK') {
       const parent: NODE | undefined = node.parent;
 
       if (!parent) {
@@ -591,22 +591,22 @@ export class RedBlackTree<
         let sibling = parent.right;
 
         // Cases 1 and 2: Sibling is red or both children of sibling are black
-        if (sibling?.color === RBTNColor.RED) {
-          sibling.color = RBTNColor.BLACK;
-          parent.color = RBTNColor.RED;
+        if (sibling?.color === 'RED') {
+          sibling.color = 'BLACK';
+          parent.color = 'RED';
           this._leftRotate(parent);
           sibling = parent.right;
         }
 
         // Case 3: Sibling's left child is black
-        if ((sibling?.left?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
-          if (sibling) sibling.color = RBTNColor.RED;
+        if ((sibling?.left?.color ?? 'BLACK') === 'BLACK') {
+          if (sibling) sibling.color = 'RED';
           node = parent;
         } else {
           // Case 4: Adjust colors and perform a right rotation
-          if (sibling?.left) sibling.left.color = RBTNColor.BLACK;
+          if (sibling?.left) sibling.left.color = 'BLACK';
           if (sibling) sibling.color = parent.color;
-          parent.color = RBTNColor.BLACK;
+          parent.color = 'BLACK';
           this._rightRotate(parent);
           node = this.root;
         }
@@ -615,22 +615,22 @@ export class RedBlackTree<
         let sibling = parent.left;
 
         // Cases 1 and 2: Sibling is red or both children of sibling are black
-        if (sibling?.color === RBTNColor.RED) {
-          sibling.color = RBTNColor.BLACK;
-          if (parent) parent.color = RBTNColor.RED;
+        if (sibling?.color === 'RED') {
+          sibling.color = 'BLACK';
+          if (parent) parent.color = 'RED';
           this._rightRotate(parent);
           if (parent) sibling = parent.left;
         }
 
         // Case 3: Sibling's left child is black
-        if ((sibling?.right?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
-          if (sibling) sibling.color = RBTNColor.RED;
+        if ((sibling?.right?.color ?? 'BLACK') === 'BLACK') {
+          if (sibling) sibling.color = 'RED';
           node = parent;
         } else {
           // Case 4: Adjust colors and perform a left rotation
-          if (sibling?.right) sibling.right.color = RBTNColor.BLACK;
+          if (sibling?.right) sibling.right.color = 'BLACK';
           if (sibling) sibling.color = parent.color;
-          if (parent) parent.color = RBTNColor.BLACK;
+          if (parent) parent.color = 'BLACK';
           this._leftRotate(parent);
           node = this.root;
         }
@@ -639,7 +639,7 @@ export class RedBlackTree<
 
     // Ensure that the final node (possibly the root) is black
     if (node) {
-      node.color = RBTNColor.BLACK;
+      node.color = 'BLACK';
     }
   }
 

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

@@ -9,6 +9,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
@@ -24,17 +25,19 @@ export class TreeMultiMapNode<
   NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>
 > extends RedBlackTreeNode<K, V, NODE> {
   /**
-   * The constructor function initializes an instance of a class with a key, value, and count.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-   * constructor. It is required and must be provided when creating an instance of the class.
-   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-   * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-   * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-   * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-   * 1.
+   * 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
+   * used to identify and locate the node within the tree.
+   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+   * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+   * creating a new node.
+   * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+   * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+   * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+   * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
    */
-  constructor(key: K, value?: V, count = 1) {
-    super(key, value);
+  constructor(key: K, value?: V, count = 1, color: RBTNColor = 'BLACK') {
+    super(key, value, color);
     this.count = count;
   }
 
@@ -91,25 +94,41 @@ export class TreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
   }
 
   /**
-   * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+   * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
    * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-   * which is a generic type that can be replaced with any specific type when using the function.
-   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-   * associated with the key in the node. It is of type `V`, which can be any data type.
-   * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-   * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-   * default to 1.
-   * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+   * which is a generic type representing the key type of the node.
+   * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+   * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+   * function. If provided, it should be of type `V`.
+   * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+   * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+   * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+   * the tree. It is an optional parameter and is used to keep track of the number of values associated
+   * with a key in the tree.
+   * @returns A new instance of the TreeMultiMapNode class is being returned.
    */
-  override createNode(key: K, value?: V, count?: number): NODE {
-    return new TreeMultiMapNode(key, value, count) as NODE;
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): NODE {
+    return new TreeMultiMapNode(key, value, count, color) as NODE;
   }
 
   /**
@@ -153,10 +172,10 @@ export class TreeMultiMap<
       if (key === undefined || key === null) {
         return;
       } else {
-        node = this.createNode(key, value, count);
+        node = this.createNode(key, value, 'BLACK', count);
       }
     } else if (!this.isNode(keyOrNodeOrEntry)) {
-      node = this.createNode(keyOrNodeOrEntry, value, count);
+      node = this.createNode(keyOrNodeOrEntry, value, 'BLACK', count);
     } else {
       return;
     }
@@ -314,7 +333,7 @@ export class TreeMultiMap<
     this._size--;
 
     // If the original color was black, fix the tree
-    if (originalColor === RBTNColor.BLACK) {
+    if (originalColor === 'BLACK') {
       this._deleteFixup(replacementNode);
     }
 
@@ -356,8 +375,8 @@ export class TreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
@@ -431,7 +450,7 @@ export class TreeMultiMap<
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this.createNode(key, value, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

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

@@ -247,10 +247,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(log n)
    *
    * Depth-first search (DFS) method, different traversal orders can be selected。
-   * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+   * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
-  dfs(order: DFSOrderPattern = 'pre'): E[] {
+  dfs(order: DFSOrderPattern = 'PRE'): E[] {
     const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
@@ -258,15 +258,15 @@ export class Heap<E = any> extends IterableElementBase<E> {
       const left = 2 * index + 1,
         right = left + 1;
       if (index < this.size) {
-        if (order === 'in') {
+        if (order === 'IN') {
           _dfs(left);
           result.push(this.elements[index]);
           _dfs(right);
-        } else if (order === 'pre') {
+        } else if (order === 'PRE') {
           result.push(this.elements[index]);
           _dfs(left);
           _dfs(right);
-        } else if (order === 'post') {
+        } else if (order === 'POST') {
           _dfs(left);
           _dfs(right);
           result.push(this.elements[index]);

package/src/types/common.ts

@@ -13,7 +13,7 @@ export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIG
 
 export type Comparator<K> = (a: K, b: K) => number;
 
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 

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

@@ -1,7 +1,7 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
 
-export enum RBTNColor { RED = 1, BLACK = 0}
+export type RBTNColor = 'RED' | 'BLACK';
 
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>