undirected-graph-typed 1.51.8 → 1.52.1

package/src/data-structures/queue/deque.ts

@@ -16,9 +16,9 @@ import { calcMinUnitsRequired, rangeCheck } from '../../utils';
  * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
-export class Deque<E> extends IterableElementBase<E> {
+export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E, R>> {
   /**
-   * The constructor initializes a Deque object with an optional iterable of elements and options.
+   * The constructor initializes a Deque object with optional iterable of elements and options.
    * @param elements - An iterable object (such as an array or a Set) that contains the initial
    * elements to be added to the deque. It can also be an object with a `length` or `size` property
    * that represents the number of elements in the iterable object. If no elements are provided, an
@@ -28,12 +28,13 @@ export class Deque<E> extends IterableElementBase<E> {
    * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
    * or is not a number
    */
-  constructor(elements: IterableWithSizeOrLength<E> = [], options?: DequeOptions) {
-    super();
+  constructor(elements: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R> = [], options?: DequeOptions<E, R>) {
+    super(options);
 
     if (options) {
-      const { bucketSize } = options;
+      const { bucketSize, maxLen } = options;
       if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
 
     let _size: number;
@@ -53,8 +54,12 @@ export class Deque<E> extends IterableElementBase<E> {
     this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
     this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;
 
-    for (const element of elements) {
-      this.push(element);
+    for (const el of elements) {
+      if (this.toElementFn) {
+        this.push(this.toElementFn(el as R));
+      } else {
+        this.push(el as E);
+      }
     }
   }
 
@@ -69,6 +74,17 @@ export class Deque<E> extends IterableElementBase<E> {
     return this._bucketSize;
   }
 
+  protected _maxLen: number = -1;
+
+  /**
+   * The maxLen function returns the max length of the deque.
+   *
+   * @return The max length of the deque
+   */
+  get maxLen() {
+    return this._maxLen;
+  }
+
   protected _bucketFirst = 0;
 
   /**
@@ -189,6 +205,7 @@ export class Deque<E> extends IterableElementBase<E> {
     }
     this._size += 1;
     this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.shift();
     return true;
   }
 
@@ -253,6 +270,7 @@ export class Deque<E> extends IterableElementBase<E> {
     }
     this._size += 1;
     this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.pop();
     return true;
   }
 
@@ -747,8 +765,8 @@ export class Deque<E> extends IterableElementBase<E> {
    * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
    * elements as the original deque (`this`) and the same bucket size.
    */
-  clone(): Deque<E> {
-    return new Deque<E>([...this], { bucketSize: this.bucketSize });
+  clone(): Deque<E, R> {
+    return new Deque<E, R>(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
   }
 
   /**
@@ -772,8 +790,8 @@ export class Deque<E> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `Deque` object that contains the elements that
    * satisfy the given predicate function.
    */
-  filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E> {
-    const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
+  filter(predicate: ElementCallback<E, R, boolean, Deque<E, R>>, thisArg?: any): Deque<E, R> {
+    const newDeque = new Deque<E, R>([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -788,21 +806,28 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
+
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function creates a new Deque by applying a callback function to each element of the
-   * original Deque.
-   * @param callback - The `callback` parameter is a function that will be called for each element in
-   * the deque. It takes three arguments:
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `callback` function. If `thisArg` is
-   * @returns a new Deque object with the mapped values.
-   */
-  map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T> {
-    const newDeque = new Deque<T>([], { bucketSize: this._bucketSize });
+   * The `map` function takes a callback function and applies it to each element in the deque,
+   * returning a new deque with the results.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * deque. It takes three arguments: the current element, the index of the element, and the deque
+   * itself. It should return a value of type EM.
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * transform the raw element (`RM`) into a new element (`EM`) before adding it to the new deque. If
+   * provided, this function will be called for each raw element in the original deque.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used to set the context or scope
+   * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+   * value of
+   * @returns a new Deque object with elements of type EM and raw elements of type RM.
+   */
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, Deque<E, R>>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): Deque<EM, RM> {
+    const newDeque = new Deque<EM, RM>([], { bucketSize: this._bucketSize, toElementFn });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));
@@ -814,9 +839,9 @@ export class Deque<E> extends IterableElementBase<E> {
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
-   * /
+   */
 
-   /**
+  /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    *

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

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, QueueOptions } from '../../types';
 import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
 
@@ -16,17 +16,14 @@ import { SinglyLinkedList } from '../linked-list';
  * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
-export class Queue<E = any> extends IterableElementBase<E> {
-  /**
-   * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
-   * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-   * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
-   * initialized as an empty array.
-   */
-  constructor(elements: Iterable<E> = []) {
-    super();
+export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: QueueOptions<E, R>) {
+    super(options);
     if (elements) {
-      for (const el of elements) this.push(el);
+      for (const el of elements) {
+        if (this.toElementFn) this.push(this.toElementFn(el as R));
+        else this.push(el as E);
+      }
     }
   }
 
@@ -103,7 +100,6 @@ export class Queue<E = any> extends IterableElementBase<E> {
    *
    * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
    * @public
-   * @static
    * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
    * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
    * array.
@@ -190,7 +186,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @param index
    */
   at(index: number): E | undefined {
-    return this.elements[index];
+    return this.elements[index + this._offset];
   }
 
   /**
@@ -254,8 +250,8 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * The `clone()` function returns a new Queue object with the same elements as the original Queue.
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
    */
-  clone(): Queue<E> {
-    return new Queue(this.elements.slice(this.offset));
+  clone(): Queue<E, R> {
+    return new Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn });
   }
 
   /**
@@ -279,8 +275,8 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `Queue` object that contains the elements that
    * satisfy the given predicate function.
    */
-  filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Queue<E> {
-    const newDeque = new Queue<E>([]);
+  filter(predicate: ElementCallback<E, R, boolean, Queue<E, R>>, thisArg?: any): Queue<E, R> {
+    const newDeque = new Queue<E, R>([], { toElementFn: this.toElementFn });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -296,22 +292,12 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(n)
    */
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function takes a callback function and applies it to each element in the queue,
-   * returning a new queue with the results.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * queue. It takes three arguments: the current element, the index of the current element, and the
-   * queue itself. The callback function should return a new value that will be added to the new queue.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `callback` function. If `thisArg` is
-   * @returns The `map` function is returning a new `Queue` object with the transformed elements.
-   */
-  map<T>(callback: ElementCallback<E, T>, thisArg?: any): Queue<T> {
-    const newDeque = new Queue<T>([]);
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, Queue<E, R>>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): Queue<EM, RM> {
+    const newDeque = new Queue<EM, RM>([], { toElementFn });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));
@@ -332,7 +318,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
   protected* _getIterator(): IterableIterator<E> {
-    for (const item of this.elements) {
+    for (const item of this.elements.slice(this.offset)) {
       yield item;
     }
   }
@@ -344,7 +330,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
  * 3. Memory Usage: Since each element requires additional space to store a pointer to the next element, linked lists may use more memory compared to arrays.
  * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
  */
-export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+export class LinkedListQueue<E = any, R = any> extends SinglyLinkedList<E, R> {
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -358,7 +344,7 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
    * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
    * values as the original `LinkedListQueue`.
    */
-  clone(): LinkedListQueue<E> {
-    return new LinkedListQueue<E>(this.values());
+  override clone(): LinkedListQueue<E, R> {
+    return new LinkedListQueue<E, R>(this, { toElementFn: this.toElementFn });
   }
 }

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, StackOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
 /**
@@ -16,17 +16,17 @@ import { IterableElementBase } from '../base';
  * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
  * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
-export class Stack<E = any> extends IterableElementBase<E> {
-  /**
-   * The constructor initializes an array of elements, which can be provided as an optional parameter.
-   * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-   * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-   * is provided and is an array, it is assigned to the `_elements
-   */
-  constructor(elements: Iterable<E> = []) {
-    super();
+export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E, R>> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: StackOptions<E, R>) {
+    super(options);
     if (elements) {
-      for (const el of elements) this.push(el);
+      for (const el of elements) {
+        if (this.toElementFn) {
+          this.push(this.toElementFn(el as R));
+        } else {
+          this.push(el as E);
+        }
+      }
     }
   }
 
@@ -192,8 +192,8 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
    * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
    */
-  clone(): Stack<E> {
-    return new Stack(this.elements.slice());
+  clone(): Stack<E, R> {
+    return new Stack<E, R>(this, { toElementFn: this.toElementFn });
   }
 
   /**
@@ -217,8 +217,8 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `Stack` object that contains the elements that
    * satisfy the given predicate function.
    */
-  filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Stack<E> {
-    const newStack = new Stack<E>();
+  filter(predicate: ElementCallback<E, R, boolean, Stack<E, R>>, thisArg?: any): Stack<E, R> {
+    const newStack = new Stack<E, R>([], { toElementFn: this.toElementFn });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -235,20 +235,25 @@ export class Stack<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
    * The `map` function takes a callback function and applies it to each element in the stack,
    * returning a new stack with the results.
-   * @param callback - The `callback` parameter is a function that will be called for each element in
-   * the stack. It takes three arguments:
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `callback` function. If `thisArg` is
-   * @returns The `map` method is returning a new `Stack` object.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * stack. It takes three arguments: the current element, the index of the element, and the stack
+   * itself. It should return a new value that will be added to the new stack.
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * transform the raw element (`RM`) into a new element (`EM`) before pushing it into the new stack.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used to set the context or scope
+   * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+   * value of
+   * @returns a new Stack object with elements of type EM and raw elements of type RM.
    */
-  map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T> {
-    const newStack = new Stack<T>();
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, Stack<E, R>>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): Stack<EM, RM> {
+    const newStack = new Stack<EM, RM>([], { toElementFn });
     let index = 0;
     for (const el of this) {
       newStack.push(callback.call(thisArg, el, index, this));

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

@@ -91,23 +91,29 @@ export class TrieNode {
  * 8. Autocomplete: Providing recommended words or phrases as a user types.
  * 9. Spell Check: Checking the spelling of words.
  * 10. IP Routing: Used in certain types of IP routing algorithms.
- * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
+ * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
  */
-export class Trie extends IterableElementBase<string, Trie> {
+export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
   /**
    * The constructor function for the Trie class.
    * @param words: Iterable string Initialize the trie with a set of words
    * @param options?: TrieOptions Allow the user to pass in options for the trie
    * @return This
    */
-  constructor(words: Iterable<string> = [], options?: TrieOptions) {
-    super();
+  constructor(words: Iterable<string> | Iterable<R> = [], options?: TrieOptions<R>) {
+    super(options);
     if (options) {
       const { caseSensitive } = options;
       if (caseSensitive !== undefined) this._caseSensitive = caseSensitive;
     }
     if (words) {
-      for (const word of words) this.add(word);
+      for (const word of words) {
+        if (this.toElementFn) {
+          this.add(this.toElementFn(word as R));
+        } else {
+          this.add(word as string);
+        }
+      }
     }
   }
 
@@ -187,7 +193,7 @@ export class Trie extends IterableElementBase<string, Trie> {
    * @param {string} word - The word to check for.
    * @returns {boolean} True if the word is present in the Trie.
    */
-  has(word: string): boolean {
+  override has(word: string): boolean {
     word = this._caseProcess(word);
     let cur = this.root;
     for (const c of word) {
@@ -470,8 +476,8 @@ export class Trie extends IterableElementBase<string, Trie> {
    * sensitivity as the original Trie.
    * @returns A new instance of the Trie class is being returned.
    */
-  clone(): Trie {
-    return new Trie(this.values(), { caseSensitive: this.caseSensitive });
+  clone(): Trie<R> {
+    return new Trie<R>(this, { caseSensitive: this.caseSensitive, toElementFn: this.toElementFn });
   }
 
   /**
@@ -493,8 +499,8 @@ export class Trie extends IterableElementBase<string, Trie> {
    * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
    * @returns The `filter` method is returning an array of strings (`string[]`).
    */
-  filter(predicate: ElementCallback<string, boolean>, thisArg?: any): Trie {
-    const results: Trie = new Trie();
+  filter(predicate: ElementCallback<string, R, boolean, Trie<R>>, thisArg?: any): Trie<R> {
+    const results = new Trie<R>([], { toElementFn: this.toElementFn, caseSensitive: this.caseSensitive });
     let index = 0;
     for (const word of this) {
       if (predicate.call(thisArg, word, index, this)) {
@@ -514,17 +520,26 @@ export class Trie extends IterableElementBase<string, Trie> {
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `map` function creates a new Trie by applying a callback function to each element in the Trie.
+   * The `map` function creates a new Trie by applying a callback function to each element in the
+   * current Trie.
    * @param callback - The callback parameter is a function that will be called for each element in the
-   * Trie. It takes three arguments: the current element in the Trie, the index of the current element,
-   * and the Trie itself. The callback function should return a new value for the element.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-   * passed as the `this` value to the `callback` function. If `thisArg` is
-   * @returns The `map` function is returning a new Trie object.
-   */
-  map(callback: ElementCallback<string, string>, thisArg?: any): Trie {
-    const newTrie = new Trie();
+   * Trie. It takes four arguments:
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * convert the raw element (`RM`) into a string representation. This can be useful if the raw element
+   * is not already a string or if you want to customize how the element is converted into a string. If
+   * this parameter is
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used to set the context or scope
+   * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
+   * value of
+   * @returns a new Trie object.
+   */
+  map<RM>(
+    callback: ElementCallback<string, R, string, Trie<R>>,
+    toElementFn?: (rawElement: RM) => string,
+    thisArg?: any
+  ): Trie<RM> {
+    const newTrie = new Trie<RM>([], { toElementFn, caseSensitive: this.caseSensitive });
     let index = 0;
     for (const word of this) {
       newTrie.add(callback.call(thisArg, word, index, this));

package/src/interfaces/binary-tree.ts

@@ -5,23 +5,23 @@ import type {
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
-  Comparable,
-  KeyOrNodeOrEntry
+  BTNKeyOrNodeOrEntry
 } from '../types';
 
 export interface IBinaryTree<
-  K extends Comparable,
+  K = any,
   V = any,
-  N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>,
-  TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>
+  R = [K, V],
+  NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>,
+  TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTreeNested<K, V, R, NODE>
 > {
-  createNode(key: K, value?: N['value']): N;
+  createNode(key: K, value?: NODE['value']): NODE;
 
-  createTree(options?: Partial<BinaryTreeOptions>): TREE;
+  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
 
-  add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
 
-  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
+  delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<NODE>[];
 }

package/src/types/common.ts

@@ -1,12 +1,5 @@
-export type BSTVariant = 'STANDARD' | 'INVERSE';
 export type CP = 1 | -1 | 0;
 
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
@@ -17,8 +10,6 @@ export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 
-export type BTNCallback<N, D = any> = (node: N) => D;
-
 export interface IterableWithSize<T> extends Iterable<T> {
   size: number | ((...args: any[]) => number);
 }
@@ -27,22 +18,8 @@ export interface IterableWithLength<T> extends Iterable<T> {
   length: number | ((...args: any[]) => number);
 }
 
-export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
-
-export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
-
-export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
-
-export type BTNKeyOrNode<K, N> = K | null | undefined | N;
+export type OptValue<V> = V | undefined;
 
-export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
-
-export type BTNodePureKeyOrNode<K, N> = K | N;
-
-export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
-
-export type BSTNKeyOrNode<K, N> = K | undefined | N;
-
-export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
 
 export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

package/src/types/data-structures/base/base.ts

@@ -1,7 +1,7 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 
 export type EntryCallback<K, V, R> = (value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
-export type ElementCallback<V, R> = (element: V, index: number, container: IterableElementBase<V>) => R;
+export type ElementCallback<E, R, RT, C> = (element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
 export type ReduceEntryCallback<K, V, R> = (
   accumulator: R,
   value: V,
@@ -9,9 +9,17 @@ export type ReduceEntryCallback<K, V, R> = (
   index: number,
   container: IterableEntryBase<K, V>
 ) => R;
-export type ReduceElementCallback<V, R> = (
-  accumulator: R,
-  element: V,
+export type ReduceElementCallback<E, R, RT, C> = (
+  accumulator: RT,
+  element: E,
   index: number,
-  container: IterableElementBase<V>
-) => R;
+  container: IterableElementBase<E, R, C>
+) => RT;
+
+// export type IterableEntryBaseOptions<K, V, R> = {
+//   toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
+// };
+
+export type IterableElementBaseOptions<E, R> = {
+  toElementFn?: (rawElement: R) => E;
+};

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

@@ -1,9 +1,8 @@
 import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
-import { Comparable } from "../../utils";
 
-export type AVLTreeMultiMapNodeNested<K extends Comparable, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type AVLTreeMultiMapNested<K extends Comparable, V, N extends AVLTreeMultiMapNode<K, V, N>> = AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type AVLTreeMultiMapNested<K, V, R, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMap<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type AVLTreeMultiMapOptions<K> = AVLTreeOptions<K> & {}
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {}