red-black-tree-typed 1.53.7 → 1.54.2

package/src/data-structures/graph/directed-graph.ts

@@ -45,6 +45,9 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class DirectedGraph<
     V = any,
     E = any,

package/src/data-structures/graph/map-graph.ts

@@ -40,6 +40,9 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class MapGraph<
   V = any,
   E = any,

package/src/data-structures/graph/undirected-graph.ts

@@ -42,6 +42,9 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class UndirectedGraph<
     V = any,
     E = any,

package/src/data-structures/hash/hash-map.ts

@@ -97,6 +97,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function checks if a given element is an array with exactly two elements.
    * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
    * data type.
@@ -107,6 +110,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function checks if the size of an object is equal to zero and returns a boolean value.
    * @returns A boolean value indicating whether the size of the object is 0 or not.
    */
@@ -115,6 +121,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The clear() function resets the state of an object by clearing its internal store, object map, and
    * size.
    */
@@ -125,6 +134,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
    * the key is not already present.
    * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
@@ -150,6 +162,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
    * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
    * pair using a mapping function, and sets each key-value pair in the current object.
    * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
@@ -175,6 +190,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The `get` function retrieves a value from a map based on a given key, either from an object map or
    * a string map.
    * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
@@ -192,6 +210,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
    * is an object key or not.
    * @param {K} key - The parameter "key" is of type K, which means it can be any type.
@@ -207,6 +228,9 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The `delete` function removes an element from a map-like data structure based on the provided key.
    * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
    * data structure.
@@ -263,7 +287,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     const resultMap = new HashMap<K, VM>();
     let index = 0;
     for (const [key, value] of this) {
-      resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+      resultMap.set(key, callbackfn.call(thisArg, key, value, index++, this));
     }
     return resultMap;
   }
@@ -288,7 +312,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     const filteredMap = new HashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, value, key, index++, this)) {
+      if (predicate.call(thisArg, key, value, index++, this)) {
         filteredMap.set(key, value);
       }
     }
@@ -579,6 +603,9 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
   }
 
   /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
    * The function `setMany` takes an iterable collection, converts each element into a key-value pair
    * using a provided function, and sets each key-value pair in the current object, returning an array
    * of booleans indicating the success of each set operation.
@@ -605,6 +632,9 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function checks if a given key exists in a map, using different logic depending on whether the
    * key is a weak key or not.
    * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
@@ -796,7 +826,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const filteredMap = new LinkedHashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, value, key, index, this)) {
+      if (predicate.call(thisArg, key, value, index, this)) {
         filteredMap.set(key, value);
       }
       index++;
@@ -821,12 +851,12 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
    * function.
    */
-  map<VM>(callback: EntryCallback<K, V, VM>, thisArg?: any): LinkedHashMap<K, VM> {
-    const mappedMap = new LinkedHashMap<K, VM>();
+  map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): LinkedHashMap<MK, MV> {
+    const mappedMap = new LinkedHashMap<MK, MV>();
     let index = 0;
     for (const [key, value] of this) {
-      const newValue = callback.call(thisArg, value, key, index, this);
-      mappedMap.set(key, newValue);
+      const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+      mappedMap.set(newKey, newValue);
       index++;
     }
     return mappedMap;

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

@@ -207,12 +207,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
       if (comparator) this._comparator = comparator;
     }
 
-    if (elements) {
-      for (const el of elements) {
-        if (this.toElementFn) this.add(this.toElementFn(el as R));
-        else this.add(el as E);
-      }
-    }
+    this.addMany(elements);
   }
 
   protected _elements: E[] = [];
@@ -254,14 +249,42 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Insert an element into the heap and maintain the heap properties.
-   * @param element - The element to be inserted.
+   * The add function pushes an element into an array and then triggers a bubble-up operation.
+   * @param {E} element - The `element` parameter represents the element that you want to add to the
+   * data structure.
+   * @returns The `add` method is returning a boolean value, which is the result of calling the
+   * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
    */
   add(element: E): boolean {
-    this._elements.push(element);
+    this._elements.push(element as E);
     return this._bubbleUp(this.elements.length - 1);
   }
 
+  /**
+   * Time Complexity: O(k log n)
+   * Space Complexity: O(1)
+   *
+   * The `addMany` function iterates over elements and adds them to a collection, returning an array of
+   * boolean values indicating success or failure.
+   * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
+   * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
+   * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
+   * provided, it transforms the element
+   * @returns The `addMany` method returns an array of boolean values indicating whether each element
+   * in the input iterable was successfully added to the data structure.
+   */
+  addMany(elements: Iterable<E> | Iterable<R>): boolean[] {
+    const ans: boolean[] = [];
+    for (const el of elements) {
+      if (this._toElementFn) {
+        ans.push(this.add(this._toElementFn(el as R)));
+        continue;
+      }
+      ans.push(this.add(el as E));
+    }
+    return ans;
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -473,7 +496,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
   }
 
   /**
-   * Time Complexity: O(n log n)
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
    * The `map` function creates a new heap by applying a callback function to each element of the

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -524,18 +524,15 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
    * configuration options to customize the behavior of the DoublyLinkedList.
    */
-  constructor(elements: Iterable<E> | Iterable<R> = [], options?: DoublyLinkedListOptions<E, R>) {
+  constructor(
+    elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>> = [],
+    options?: DoublyLinkedListOptions<E, R>
+  ) {
     super(options);
     this._head = undefined;
     this._tail = undefined;
     this._size = 0;
-    if (elements) {
-      for (const el of elements) {
-        if (this.toElementFn) {
-          this.push(this.toElementFn(el as R));
-        } else this.push(el as E);
-      }
-    }
+    this.pushMany(elements);
   }
 
   protected _head: DoublyLinkedListNode<E> | undefined;
@@ -591,6 +588,19 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return this.tail?.value;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+   * given array.
+   * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+   * @returns The `fromArray` function returns a DoublyLinkedList object.
+   */
+  static fromArray<E>(data: E[]) {
+    return new DoublyLinkedList<E>(data);
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -700,6 +710,57 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return true;
   }
 
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+   * transformation function if provided.
+   * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+   * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+   * or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and pushes
+   * it onto the linked list. If a transformation function `to
+   * @returns The `pushMany` function is returning an array of boolean values (`ans`) which indicate
+   * the success or failure of pushing each element into the data structure.
+   */
+  pushMany(elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>) {
+    const ans: boolean[] = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.push(this.toElementFn(el as R)));
+        continue;
+      }
+      ans.push(this.push(el as E | DoublyLinkedListNode<E>));
+    }
+    return ans;
+  }
+
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The function `unshiftMany` iterates through a collection of elements and adds them to the
+   * beginning of a Doubly Linked List, returning an array of boolean values indicating the success of
+   * each insertion.
+   * @param {Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>} elements - The `elements`
+   * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+   * `R`, or `DoublyLinkedListNode<E>`. The function iterates over each element in the iterable and
+   * performs an `unshift` operation on the doubly linked list
+   * @returns The `unshiftMany` function returns an array of boolean values indicating the success of
+   * each unshift operation performed on the elements passed as input.
+   */
+  unshiftMany(elements: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>) {
+    const ans: boolean[] = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.unshift(this.toElementFn(el as R)));
+        continue;
+      }
+      ans.push(this.unshift(el as E | DoublyLinkedListNode<E>));
+    }
+    return ans;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -1182,6 +1243,12 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
+   * The function `countOccurrences` iterates through a doubly linked list and counts the occurrences
+   * of a specified element or nodes that satisfy a given predicate.
+   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementOrNode
+   * - The `elementOrNode` parameter in the `countOccurrences` method can accept three types of values:
+   * @returns The `countOccurrences` method returns the number of occurrences of the specified element,
+   * node, or predicate function in the doubly linked list.
    */
   countOccurrences(elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number {
     const predicate = this._ensurePredicate(elementOrNode);
@@ -1198,19 +1265,6 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return count;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-   * given array.
-   * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-   * @returns The `fromArray` function returns a DoublyLinkedList object.
-   */
-  static fromArray<E>(data: E[]) {
-    return new DoublyLinkedList<E>(data);
-  }
-
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -59,18 +59,16 @@ export class SinglyLinkedListNode<E = any> {
   }
 }
 
+/**
+ *
+ */
 export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
-  constructor(elements: Iterable<E> | Iterable<R> = [], options?: SinglyLinkedListOptions<E, R>) {
+  constructor(
+    elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>> = [],
+    options?: SinglyLinkedListOptions<E, R>
+  ) {
     super(options);
-    if (elements) {
-      for (const el of elements) {
-        if (this.toElementFn) {
-          this.push(this.toElementFn(el as R));
-        } else {
-          this.push(el as E);
-        }
-      }
-    }
+    this.pushMany(elements);
   }
 
   protected _head: SinglyLinkedListNode<E> | undefined;
@@ -121,6 +119,23 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return this._size;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
+   * array.
+   * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+   * @returns The `fromArray` function returns a `SinglyLinkedList` object.
+   */
+  static fromArray<E>(data: E[]) {
+    const singlyLinkedList = new SinglyLinkedList<E>();
+    for (const item of data) {
+      singlyLinkedList.push(item);
+    }
+    return singlyLinkedList;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -211,6 +226,55 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return true;
   }
 
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The function `pushMany` iterates over elements and pushes them into a data structure, applying a
+   * transformation function if provided.
+   * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+   * parameter in the `pushMany` function can accept an iterable containing elements of type `E`, `R`,
+   * or `SinglyLinkedListNode<E>`.
+   * @returns The `pushMany` function returns an array of boolean values indicating whether each
+   * element was successfully pushed into the data structure.
+   */
+  pushMany(elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>) {
+    const ans: boolean[] = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.push(this.toElementFn(el as R)));
+        continue;
+      }
+      ans.push(this.push(el as E | SinglyLinkedListNode<E>));
+    }
+    return ans;
+  }
+
+  /**
+   * Time Complexity: O(k)
+   * Space Complexity: O(k)
+   *
+   * The function `unshiftMany` iterates over elements and adds them to a data structure, optionally
+   * converting them using a provided function.
+   * @param {Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>} elements - The `elements`
+   * parameter in the `unshiftMany` function can accept an iterable containing elements of type `E`,
+   * `R`, or `SinglyLinkedListNode<E>`. The function iterates over each element in the iterable and
+   * performs an `unshift` operation on the linked list for each
+   * @returns The `unshiftMany` function is returning an array of boolean values, where each value
+   * represents the result of calling the `unshift` method on the current instance of the class.
+   */
+  unshiftMany(elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>) {
+    const ans: boolean[] = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        ans.push(this.unshift(this.toElementFn(el as R)));
+        continue;
+      }
+      ans.push(this.unshift(el as E | SinglyLinkedListNode<E>));
+    }
+    return ans;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -399,6 +463,9 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function checks if the length of a data structure is equal to zero and returns a boolean value indicating
    * whether it is empty or not.
    * @returns A boolean value indicating whether the length of the object is equal to 0.
@@ -408,6 +475,9 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
    */
   clear(): void {
@@ -713,23 +783,6 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     }
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
-   * array.
-   * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-   * @returns The `fromArray` function returns a `SinglyLinkedList` object.
-   */
-  static fromArray<E>(data: E[]) {
-    const singlyLinkedList = new SinglyLinkedList<E>();
-    for (const item of data) {
-      singlyLinkedList.push(item);
-    }
-    return singlyLinkedList;
-  }
-
   /**
    * The _isPredicate function in TypeScript checks if the input is a function that takes a
    * SinglyLinkedListNode as an argument and returns a boolean.

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -19,6 +19,9 @@ export class SkipListNode<K, V> {
   }
 }
 
+/**
+ *
+ */
 export class SkipList<K, V> {
   /**
    * The constructor function initializes a SkipLinkedList object with optional options and elements.

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

@@ -7,6 +7,9 @@
  */
 import type { MatrixOptions } from '../../types';
 
+/**
+ *
+ */
 export class Matrix {
   /**
    * The constructor function initializes a matrix object with the provided data and options, or with

package/src/data-structures/matrix/navigator.ts

@@ -25,6 +25,9 @@ export class Character {
   }
 }
 
+/**
+ *
+ */
 export class Navigator<T = number> {
   onMove: (cur: [number, number]) => void;
   protected readonly _matrix: T[][];

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

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a

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

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a