doubly-linked-list-typed 1.51.8 → 1.52.0

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

@@ -18,21 +18,24 @@ import { IterableElementBase } from '../base';
  * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prime's minimum-spanning tree algorithm, which use heaps to improve performance.
  */
-export class Heap<E = any> extends IterableElementBase<E> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
   /**
    * The constructor initializes a heap data structure with optional elements and options.
    * @param elements - The `elements` parameter is an iterable object that contains the initial
-   * elements to be added to the heap. It is an optional parameter and if not provided, the heap will
+   * elements to be added to the heap.
+   * It is an optional parameter, and if not provided, the heap will
    * be initialized as empty.
    * @param [options] - The `options` parameter is an optional object that can contain additional
-   * configuration options for the heap. In this case, it is used to specify a custom comparator
-   * function for comparing elements in the heap. The comparator function is used to determine the
+   * configuration options for the heap.
+   * In this case, it is used to specify a custom comparator
+   * function for comparing elements in the heap.
+   * The comparator function is used to determine the
    * order of elements in the heap.
    */
-  constructor(elements: Iterable<E> = [], options?: HeapOptions<E>) {
-    super();
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {
+    super(options);
 
     if (options) {
       const { comparator } = options;
@@ -41,32 +44,17 @@ export class Heap<E = any> extends IterableElementBase<E> {
 
     if (elements) {
       for (const el of elements) {
-        this.add(el);
+        if (this.toElementFn) this.add(this.toElementFn(el as R));
+        else this.add(el as E);
       }
     }
   }
 
-  protected _comparator = (a: E, b: E) => {
-    if (!(typeof a === 'number' && typeof b === 'number')) {
-      throw new Error('The a, b params of compare function must be number');
-    } else {
-      return a - b;
-    }
-  };
-
-  /**
-   * The function returns the value of the _comparator property.
-   * @returns The `_comparator` property is being returned.
-   */
-  get comparator() {
-    return this._comparator;
-  }
-
   protected _elements: E[] = [];
 
   /**
    * The function returns an array of elements.
-   * @returns The elements array is being returned.
+   * @returns The element array is being returned.
    */
   get elements(): E[] {
     return this._elements;
@@ -93,16 +81,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @param elements
    * @param options
    */
-  static heapify<E>(elements: Iterable<E>, options: HeapOptions<E>): Heap<E> {
+  static heapify<E = any, R = any>(elements: Iterable<E>, options: HeapOptions<E, R>): Heap<E> {
     return new Heap<E>(elements, options);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   * where n is the number of elements in the heap.
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -115,17 +97,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return this._bubbleUp(this.elements.length - 1);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   * where n is the number of elements in the heap.
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Remove and return the top element (smallest or largest element) from the heap.
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @returns The top element or undefined if the heap is empty.
    */
   poll(): E | undefined {
@@ -139,11 +115,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return value;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -170,11 +141,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     this._elements = [];
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -187,11 +153,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return this.fix();
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -205,13 +166,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity:  O(n)
-   * Space Complexity: O(1)
-   * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
-   */
-
-  /**
-   * Time Complexity:  O(n)
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -236,12 +191,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return true;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   * where log n is the height of the heap.
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(log n)
@@ -279,11 +228,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return result;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -295,11 +239,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return [...this.elements];
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -307,17 +246,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Clone the heap, creating a new heap with the same elements.
    * @returns A new Heap instance containing the same elements.
    */
-  clone(): Heap<E> {
-    const clonedHeap = new Heap<E>([], { comparator: this.comparator });
-    clonedHeap._elements = [...this.elements];
-    return clonedHeap;
+  clone(): Heap<E, R> {
+    return new Heap<E, R>(this, { comparator: this.comparator, toElementFn: this.toElementFn });
   }
 
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(n)
@@ -327,19 +259,14 @@ export class Heap<E = any> extends IterableElementBase<E> {
    */
   sort(): E[] {
     const visitedNode: E[] = [];
-    const cloned = this.clone();
+    const cloned = new Heap<E, R>(this, { comparator: this.comparator });
     while (cloned.size !== 0) {
       const top = cloned.poll();
-      if (top) visitedNode.push(top);
+      if (top !== undefined) visitedNode.push(top);
     }
     return visitedNode;
   }
 
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n log n)
    * Space Complexity: O(n)
@@ -352,11 +279,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return results;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -373,8 +295,8 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  filter(callback: ElementCallback<E, boolean>, thisArg?: any): Heap<E> {
-    const filteredList = new Heap<E>();
+  filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R> {
+    const filteredList = new Heap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
@@ -386,32 +308,33 @@ export class Heap<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
-  /**
-   * Time Complexity: O(n)
+   * Time Complexity: O(n log n)
    * Space Complexity: O(n)
    *
    * The `map` function creates a new heap by applying a callback function to each element of the
    * original heap.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * original heap. It takes three arguments: the current element, the index of the current element,
-   * and the original heap itself. The callback function should return a value of type T, which will be
-   * added to the mapped heap.
-   * @param comparator - The `comparator` parameter is a function that is used to compare elements in
-   * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
-   * `b`, a positive number if `a` is greater than `b`, or
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+   * element), and `this` (the heap itself). The callback function should return a value of
+   * @param comparator - The `comparator` parameter is a function that defines the order of the
+   * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+   * if `a` should be placed before `b`, a positive number if `a` should be placed after
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+   * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+   * returns a value of type `T`. This function is used to transform the elements of the original
    * @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 when you want to bind a
-   * specific object as the context for the callback function. If `thisArg` is not provided,
-   * `undefined` is used as
-   * @returns a new instance of the Heap class, which is created using the mapped elements from the
-   * original Heap.
-   */
-  map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T> {
-    const mappedHeap: Heap<T> = new Heap<T>([], { comparator: comparator });
+   * 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 instance of the `Heap` class with the mapped elements.
+   */
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, Heap<E, R>>,
+    comparator: Comparator<EM>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): Heap<EM, RM> {
+    const mappedHeap: Heap<EM, RM> = new Heap<EM, RM>([], { comparator, toElementFn });
     let index = 0;
     for (const el of this) {
       mappedHeap.add(callback.call(thisArg, el, index, this));
@@ -420,6 +343,27 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return mappedHeap;
   }
 
+  protected _DEFAULT_COMPARATOR = (a: E, b: E): number => {
+    if (typeof a === 'object' || typeof b === 'object') {
+      throw TypeError(
+        `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+      );
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  };
+
+  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;
+
+  /**
+   * The function returns the value of the _comparator property.
+   * @returns The `_comparator` property is being returned.
+   */
+  get comparator() {
+    return this._comparator;
+  }
+
   /**
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
@@ -429,11 +373,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     }
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -454,11 +393,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return true;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -580,11 +514,6 @@ export class FibonacciHeap<E> {
     this._size = 0;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -597,11 +526,6 @@ export class FibonacciHeap<E> {
     return this.push(element);
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -624,11 +548,6 @@ export class FibonacciHeap<E> {
     return this;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -702,7 +621,7 @@ export class FibonacciHeap<E> {
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Remove and return the top element (smallest or largest element) from the heap.
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @returns The top element or undefined if the heap is empty.
    */
   poll(): E | undefined {
@@ -718,7 +637,7 @@ export class FibonacciHeap<E> {
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    *
-   * Remove and return the top element (smallest or largest element) from the heap.
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @returns The top element or undefined if the heap is empty.
    */
   pop(): E | undefined {
@@ -844,8 +763,8 @@ export class FibonacciHeap<E> {
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
-   *.
-   * Remove and return the top element (smallest or largest element) from the heap.
+   *
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @param node - The node to be removed.
    * @protected
    */
@@ -864,7 +783,7 @@ export class FibonacciHeap<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * Remove and return the top element (smallest or largest element) from the heap.
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @param y
    * @param x
    * @protected
@@ -887,7 +806,7 @@ export class FibonacciHeap<E> {
    * Time Complexity: O(n log n)
    * Space Complexity: O(n)
    *
-   * Remove and return the top element (smallest or largest element) from the heap.
+   * Remove and return the top element (the smallest or largest element) from the heap.
    * @protected
    */
   protected _consolidate(): void {

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { HeapOptions } from '../../types';
+import type { Comparator, ElementCallback, HeapOptions } from '../../types';
 import { Heap } from './heap';
 
 /**
@@ -16,21 +16,96 @@ import { Heap } from './heap';
  * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
  * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.
  */
-export class MaxHeap<E = any> extends Heap<E> {
-  constructor(
-    elements: Iterable<E> = [],
-    options: HeapOptions<E> = {
-      comparator: (a: E, b: E) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-          throw new Error('The a, b params of compare function must be number');
-        } else {
-          return b - a;
+export class MaxHeap<E = any, R = any> extends Heap<E, R> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {
+    super(elements, {
+      comparator: (a: E, b: E): number => {
+        if (typeof a === 'object' || typeof b === 'object') {
+          throw TypeError(
+            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
+          );
         }
+        if (a < b) return 1;
+        if (a > b) return -1;
+        return 0;
+      },
+      ...options
+    });
+  }
+
+  /**
+   * The `clone` function returns a new instance of the `MaxHeap` class with the same properties as the
+   * current instance.
+   * @returns The `clone()` method is returning a new instance of the `MaxHeap` class with the same
+   * properties as the current instance.
+   */
+  override clone(): MaxHeap<E, R> {
+    return new MaxHeap<E, R>(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new MaxHeap object containing elements that pass a given callback
+   * function.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: the current element, the index of the current element, and the
+   * heap itself. The callback function should return a boolean value indicating whether the current
+   * element should be included in the filtered list
+   * @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 `filter` method is returning a new `MaxHeap` object that contains the elements that pass
+   * the filter condition specified by the `callback` function.
+   */
+  override filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R> {
+    const filteredList = new MaxHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
+    let index = 0;
+    for (const current of this) {
+      if (callback.call(thisArg, current, index, this)) {
+        filteredList.add(current);
       }
+      index++;
+    }
+    return filteredList;
+  }
+
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function creates a new heap by applying a callback function to each element of the
+   * original heap.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+   * element), and `this` (the heap itself). The callback function should return a value of
+   * @param comparator - The `comparator` parameter is a function that defines the order of the
+   * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+   * if `a` should be placed before `b`, a positive number if `a` should be placed after
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+   * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+   * returns a value of type `T`. This function is used to transform the elements of the original
+   * @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 instance of the `MaxHeap` class with the mapped elements.
+   */
+  override map<EM, RM>(
+    callback: ElementCallback<E, R, EM, MaxHeap<E, R>>,
+    comparator: Comparator<EM>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): MaxHeap<EM, RM> {
+    const mappedHeap: MaxHeap<EM, RM> = new MaxHeap<EM, RM>([], { comparator, toElementFn });
+    let index = 0;
+    for (const el of this) {
+      mappedHeap.add(callback.call(thisArg, el, index, this));
+      index++;
     }
-  ) {
-    super(elements, options);
+    return mappedHeap;
   }
 }

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

@@ -5,32 +5,95 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { HeapOptions } from '../../types';
+import type { Comparator, ElementCallback, HeapOptions } from '../../types';
 import { Heap } from './heap';
 
 /**
  * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. Heap Properties:  The value of each parent node is less than or equal to the value of its children.
+ * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.
  * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
  * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
  * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
  * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
- * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
-export class MinHeap<E = any> extends Heap<E> {
-  constructor(
-    elements: Iterable<E> = [],
-    options: HeapOptions<E> = {
-      comparator: (a: E, b: E) => {
-        if (!(typeof a === 'number' && typeof b === 'number')) {
-          throw new Error('The a, b params of compare function must be number');
-        } else {
-          return a - b;
-        }
+export class MinHeap<E = any, R = any> extends Heap<E, R> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: HeapOptions<E, R>) {
+    super(elements, options);
+  }
+
+  /**
+   * The `clone` function returns a new instance of the `MinHeap` class with the same comparator and
+   * toElementFn as the original instance.
+   * @returns The `clone()` method is returning a new instance of the `MinHeap` class with the same
+   * properties as the current instance.
+   */
+  override clone(): MinHeap<E, R> {
+    return new MinHeap<E, R>(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new MinHeap object containing elements that pass a given callback
+   * function.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: the current element, the index of the current element, and the
+   * heap itself. The callback function should return a boolean value indicating whether the current
+   * element should be included in the filtered list
+   * @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 `filter` method is returning a new `MinHeap` object that contains the elements that pass
+   * the filter condition specified by the `callback` function.
+   */
+  override filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R> {
+    const filteredList = new MinHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
+    let index = 0;
+    for (const current of this) {
+      if (callback.call(thisArg, current, index, this)) {
+        filteredList.add(current);
       }
+      index++;
     }
-  ) {
-    super(elements, options);
+    return filteredList;
+  }
+
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function creates a new heap by applying a callback function to each element of the
+   * original heap.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
+   * element), and `this` (the heap itself). The callback function should return a value of
+   * @param comparator - The `comparator` parameter is a function that defines the order of the
+   * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
+   * if `a` should be placed before `b`, a positive number if `a` should be placed after
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
+   * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
+   * returns a value of type `T`. This function is used to transform the elements of the original
+   * @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 instance of the `MinHeap` class with the mapped elements.
+   */
+  override map<EM, RM>(
+    callback: ElementCallback<E, R, EM, MinHeap<E, R>>,
+    comparator: Comparator<EM>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): MinHeap<EM, RM> {
+    const mappedHeap: MinHeap<EM, RM> = new MinHeap<EM, RM>([], { comparator, toElementFn });
+    let index = 0;
+    for (const el of this) {
+      mappedHeap.add(callback.call(thisArg, el, index, this));
+      index++;
+    }
+    return mappedHeap;
   }
 }