queue-typed 1.47.4 → 1.47.5

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

@@ -313,12 +313,14 @@ export class HashMap<K = any, V = any> {
    * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
    * satisfy the given predicate function.
    */
-  filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V> {
+  filter(predicate: (element: [K, V], index: number, map: HashMap<K, V>) => boolean): HashMap<K, V> {
     const filteredMap = new HashMap<K, V>();
+    let index = 0;
     for (const [key, value] of this) {
-      if (predicate([key, value], this)) {
+      if (predicate([key, value], index, this)) {
         filteredMap.set(key, value);
       }
+      index++;
     }
     return filteredMap;
   }
@@ -330,11 +332,13 @@ export class HashMap<K = any, V = any> {
    * `map`.
    * @returns a new HashMap object with the values mapped according to the provided callback function.
    */
-  map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV> {
+  map<NV>(callback: (element: [K, V], index: number, map: HashMap<K, V>) => NV): HashMap<K, NV> {
     const mappedMap = new HashMap<K, NV>();
+    let index = 0;
     for (const [key, value] of this) {
-      const newValue = callback([key, value], this);
+      const newValue = callback([key, value], index, this);
       mappedMap.set(key, newValue);
+      index++;
     }
     return mappedMap;
   }
@@ -351,10 +355,12 @@ export class HashMap<K = any, V = any> {
    * @returns The `reduce` function is returning the final value of the accumulator after iterating
    * over all the elements in the HashMap and applying the callback function to each element.
    */
-  reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A {
+  reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: HashMap<K, V>) => A, initialValue: A): A {
     let accumulator = initialValue;
-    for (const element of this) {
-      accumulator = callback(accumulator, element, this);
+    let index = 0;
+    for (const entry of this) {
+      accumulator = callback(accumulator, entry, index, this);
+      index++;
     }
     return accumulator;
   }

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

@@ -9,18 +9,18 @@
 export class HashTableNode<K, V> {
   key: K;
   value: V;
-  next: HashTableNode<K, V> | null;
+  next: HashTableNode<K, V> | undefined;
 
   constructor(key: K, value: V) {
     this.key = key;
     this.value = value;
-    this.next = null;
+    this.next = undefined;
   }
 }
 
 import { HashFunction } from '../../types';
 
-export class HashTable<K, V> {
+export class HashTable<K = any, V = any> {
   protected static readonly DEFAULT_CAPACITY = 16;
   protected static readonly LOAD_FACTOR = 0.75;
 
@@ -28,7 +28,7 @@ export class HashTable<K, V> {
     this._hashFn = hashFn || this._defaultHashFn;
     this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
     this._size = 0;
-    this._buckets = new Array<HashTableNode<K, V> | null>(this._capacity).fill(null);
+    this._buckets = new Array<HashTableNode<K, V> | undefined>(this._capacity).fill(undefined);
   }
 
   protected _capacity: number;
@@ -43,9 +43,9 @@ export class HashTable<K, V> {
     return this._size;
   }
 
-  protected _buckets: Array<HashTableNode<K, V> | null>;
+  protected _buckets: Array<HashTableNode<K, V> | undefined>;
 
-  get buckets(): Array<HashTableNode<K, V> | null> {
+  get buckets(): Array<HashTableNode<K, V> | undefined> {
     return this._buckets;
   }
 
@@ -125,7 +125,7 @@ export class HashTable<K, V> {
   delete(key: K): void {
     const index = this._hash(key);
     let currentNode = this._buckets[index];
-    let prevNode: HashTableNode<K, V> | null = null;
+    let prevNode: HashTableNode<K, V> | undefined = undefined;
 
     while (currentNode) {
       if (currentNode.key === key) {
@@ -135,7 +135,7 @@ export class HashTable<K, V> {
           this._buckets[index] = currentNode.next;
         }
         this._size--;
-        currentNode.next = null; // Release memory
+        currentNode.next = undefined; // Release memory
         return;
       }
       prevNode = currentNode;
@@ -143,6 +143,56 @@ export class HashTable<K, V> {
     }
   }
 
+  * [Symbol.iterator](): Generator<[K, V], void, undefined> {
+    for (const bucket of this._buckets) {
+      let currentNode = bucket;
+      while (currentNode) {
+        yield [currentNode.key, currentNode.value];
+        currentNode = currentNode.next;
+      }
+    }
+  }
+
+  forEach(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => void): void {
+    let index = 0;
+    for (const entry of this) {
+      callback(entry, index, this);
+      index++;
+    }
+  }
+
+  filter(predicate: (entry: [K, V], index: number, table: HashTable<K, V>) => boolean): HashTable<K, V> {
+    const newTable = new HashTable<K, V>();
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate([key, value], index, this)) {
+        newTable.set(key, value);
+      }
+      index++;
+    }
+    return newTable;
+  }
+
+  map<T>(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => T): HashTable<K, T> {
+    const newTable = new HashTable<K, T>();
+    let index = 0;
+    for (const [key, value] of this) {
+      newTable.set(key, callback([key, value], index, this));
+      index++;
+    }
+    return newTable;
+  }
+
+  reduce<T>(callback: (accumulator: T, entry: [K, V], index: number, table: HashTable<K, V>) => T, initialValue: T): T {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const entry of this) {
+      accumulator = callback(accumulator, entry, index, this);
+      index++;
+    }
+    return accumulator;
+  }
+
   /**
    * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
    * capacity of the data structure.
@@ -241,7 +291,7 @@ export class HashTable<K, V> {
    */
   protected _expand(): void {
     const newCapacity = this._capacity * 2;
-    const newBuckets = new Array<HashTableNode<K, V> | null>(newCapacity).fill(null);
+    const newBuckets = new Array<HashTableNode<K, V> | undefined>(newCapacity).fill(undefined);
 
     for (const bucket of this._buckets) {
       let currentNode = bucket;

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

@@ -226,29 +226,30 @@ export class Heap<E = any> {
    * @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): E[] {
+  dfs(order: DFSOrderPattern = 'pre'): E[] {
     const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
-    const dfsHelper = (index: number) => {
+    const _dfs = (index: number) => {
+      const left = 2 * index + 1, right = left + 1;
       if (index < this.size) {
         if (order === 'in') {
-          dfsHelper(2 * index + 1);
+          _dfs(left);
           result.push(this.elements[index]);
-          dfsHelper(2 * index + 2);
+          _dfs(right);
         } else if (order === 'pre') {
           result.push(this.elements[index]);
-          dfsHelper(2 * index + 1);
-          dfsHelper(2 * index + 2);
+          _dfs(left);
+          _dfs(right);
         } else if (order === 'post') {
-          dfsHelper(2 * index + 1);
-          dfsHelper(2 * index + 2);
+          _dfs(left);
+          _dfs(right);
           result.push(this.elements[index]);
         }
       }
     };
 
-    dfsHelper(0); // Traverse starting from the root node
+    _dfs(0); // Traverse starting from the root node
 
     return result;
   }
@@ -324,6 +325,56 @@ export class Heap<E = any> {
     for (let i = Math.floor(this.size / 2); i >= 0; i--) this._sinkDown(i, this.elements.length >> 1);
   }
 
+  * [Symbol.iterator]() {
+    for (const element of this.elements) {
+      yield element;
+    }
+  }
+
+  forEach(callback: (element: E, index: number, heap: this) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
+    }
+  }
+
+  filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E> {
+    const filteredHeap: Heap<E> = new Heap<E>({ comparator: this.comparator });
+    let index = 0;
+    for (const el of this) {
+      if (predicate(el, index, this)) {
+        filteredHeap.push(el);
+      }
+      index++;
+    }
+    return filteredHeap;
+  }
+
+  map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T> {
+
+    const mappedHeap: Heap<T> = new Heap<T>({ comparator: comparator });
+    let index = 0;
+    for (const el of this) {
+      mappedHeap.add(callback(el, index, this));
+      index++;
+    }
+    return mappedHeap;
+  }
+
+  reduce<T>(
+    callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T,
+    initialValue: T
+  ): T {
+    let accumulator: T = initialValue;
+    let index = 0;
+    for (const el of this) {
+      accumulator = callback(accumulator, el, index, this);
+      index++;
+    }
+    return accumulator;
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

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

@@ -441,6 +441,50 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   *
+   * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+   * after which the new value will be inserted. It can be either the value of the existing node or the existing node
+   * itself.
+   * @param {E} newValue - The value that you want to insert into the doubly linked list.
+   * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
+   * existing value or node is not found in the doubly linked list.
+   */
+  insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
+    let existingNode;
+
+    if (existingValueOrNode instanceof DoublyLinkedListNode) {
+      existingNode = existingValueOrNode;
+    } else {
+      existingNode = this.getNode(existingValueOrNode);
+    }
+
+    if (existingNode) {
+      const newNode = new DoublyLinkedListNode(newValue);
+      newNode.next = existingNode.next;
+      if (existingNode.next) {
+        existingNode.next.prev = newNode;
+      }
+      newNode.prev = existingNode;
+      existingNode.next = newNode;
+      if (existingNode === this.tail) {
+        this._tail = newNode;
+      }
+      this._length++;
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
@@ -511,28 +555,6 @@ export class DoublyLinkedList<E = any> {
     return false;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   */
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   *
-   * The `toArray` function converts a linked list into an array.
-   * @returns The `toArray()` method is returning an array of type `E[]`.
-   */
-  toArray(): E[] {
-    const array: E[] = [];
-    let current = this.head;
-    while (current) {
-      array.push(current.value);
-      current = current.next;
-    }
-    return array;
-  }
-
   /**
    * The function checks if a variable has a length greater than zero and returns a boolean value.
    * @returns A boolean value is being returned.
@@ -631,28 +653,6 @@ export class DoublyLinkedList<E = any> {
     return null;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   */
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
-   *
-   * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
-   * @returns The `toArrayBackward()` function returns an array of type `E[]`.
-   */
-  toArrayBackward(): E[] {
-    const array: E[] = [];
-    let current = this.tail;
-    while (current) {
-      array.push(current.value);
-      current = current.prev;
-    }
-    return array;
-  }
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(1)
@@ -676,26 +676,24 @@ export class DoublyLinkedList<E = any> {
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    *
-   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-   * represents the value of the current node in the linked list, and the index argument represents the index of the
-   * current node in the linked list.
+   * The `toArray` function converts a linked list into an array.
+   * @returns The `toArray()` method is returning an array of type `E[]`.
    */
-  forEach(callback: (value: E, index: number) => void): void {
+  toArray(): E[] {
+    const array: E[] = [];
     let current = this.head;
-    let index = 0;
     while (current) {
-      callback(current.value, index);
+      array.push(current.value);
       current = current.next;
-      index++;
     }
+    return array;
   }
 
   /**
@@ -707,21 +705,51 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(n)
    *
-   * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-   * DoublyLinkedList with the transformed values.
-   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-   * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
-   * DoublyLinkedList).
-   * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+   * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
+   * @returns The `toReversedArray()` function returns an array of type `E[]`.
    */
-  map<U>(callback: (value: E) => U): DoublyLinkedList<U> {
-    const mappedList = new DoublyLinkedList<U>();
+  toReversedArray(): E[] {
+    const array: E[] = [];
+    let current = this.tail;
+    while (current) {
+      array.push(current.value);
+      current = current.prev;
+    }
+    return array;
+  }
+
+  /**
+   * The function returns an iterator that iterates over the values of a linked list.
+   */
+  * [Symbol.iterator]() {
     let current = this.head;
+
     while (current) {
-      mappedList.push(callback(current.value));
+      yield current.value;
       current = current.next;
     }
-    return mappedList;
+  }
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Space Complexity: O(1)
+   *
+   * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
+   * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
+   * represents the value of the current node in the linked list, and the index argument represents the index of the
+   * current node in the linked list.
+   */
+  forEach(callback: (value: E, index: number, list: DoublyLinkedList<E>) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
+    }
   }
 
   /**
@@ -739,14 +767,14 @@ export class DoublyLinkedList<E = any> {
    * It is used to determine whether a value should be included in the filtered list or not.
    * @returns The filtered list, which is an instance of the DoublyLinkedList class.
    */
-  filter(callback: (value: E) => boolean): DoublyLinkedList<E> {
+  filter(callback: (value: E, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E> {
     const filteredList = new DoublyLinkedList<E>();
-    let current = this.head;
-    while (current) {
-      if (callback(current.value)) {
-        filteredList.push(current.value);
+    let index = 0;
+    for (const current of this) {
+      if (callback(current, index, this)) {
+        filteredList.push(current);
       }
-      current = current.next;
+      index++;
     }
     return filteredList;
   }
@@ -760,78 +788,50 @@ export class DoublyLinkedList<E = any> {
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(n)
    *
-   * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-   * single value.
-   * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
-   * used to perform a specific operation on each element of the linked list.
-   * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-   * point for the reduction operation.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-   * elements in the linked list.
+   * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+   * DoublyLinkedList with the transformed values.
+   * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
+   * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
+   * DoublyLinkedList).
+   * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
    */
-  reduce<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U {
-    let accumulator = initialValue;
-    let current = this.head;
-    while (current) {
-      accumulator = callback(accumulator, current.value);
-      current = current.next;
+  map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T> {
+    const mappedList = new DoublyLinkedList<T>();
+    let index = 0;
+    for (const current of this) {
+      mappedList.push(callback(current, index, this));
+      index++;
     }
-    return accumulator;
+
+    return mappedList;
   }
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    *
-   * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-   * after which the new value will be inserted. It can be either the value of the existing node or the existing node
-   * itself.
-   * @param {E} newValue - The value that you want to insert into the doubly linked list.
-   * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
-   * existing value or node is not found in the doubly linked list.
+   * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
+   * single value.
+   * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
+   * used to perform a specific operation on each element of the linked list.
+   * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+   * point for the reduction operation.
+   * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+   * elements in the linked list.
    */
-  insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
-    let existingNode;
-
-    if (existingValueOrNode instanceof DoublyLinkedListNode) {
-      existingNode = existingValueOrNode;
-    } else {
-      existingNode = this.getNode(existingValueOrNode);
-    }
-
-    if (existingNode) {
-      const newNode = new DoublyLinkedListNode(newValue);
-      newNode.next = existingNode.next;
-      if (existingNode.next) {
-        existingNode.next.prev = newNode;
-      }
-      newNode.prev = existingNode;
-      existingNode.next = newNode;
-      if (existingNode === this.tail) {
-        this._tail = newNode;
-      }
-      this._length++;
-      return true;
+  reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const current of this) {
+      accumulator = callback(accumulator, current, index, this);
+      index++;
     }
 
-    return false;
-  }
-
-  /**
-   * The function returns an iterator that iterates over the values of a linked list.
-   */
-  * [Symbol.iterator]() {
-    let current = this.head;
-
-    while (current) {
-      yield current.value;
-      current = current.next;
-    }
+    return accumulator;
   }
 }