bst-typed 1.51.9 → 1.52.0

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;
   }
 }

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 
 export class DoublyLinkedListNode<E = any> {
@@ -87,21 +87,17 @@ export class DoublyLinkedListNode<E = any> {
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
  */
-export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
-  /**
-   * The constructor initializes a linked list with optional elements.
-   * @param elements - The `elements` parameter is an optional iterable object that contains the
-   * initial elements to be added to the data structure. It defaults to an empty array if no elements
-   * are provided.
-   */
-  constructor(elements: Iterable<E> = []) {
-    super();
+export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: DoublyLinkedListOptions<E, R>) {
+    super(options);
     this._head = undefined;
     this._tail = undefined;
     this._size = 0;
     if (elements) {
       for (const el of elements) {
-        this.push(el);
+        if (this.toElementFn) {
+          this.push(this.toElementFn(el as R));
+        } else this.push(el as E);
       }
     }
   }
@@ -729,8 +725,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
    * is a copy of the original list.
    */
-  clone(): DoublyLinkedList<E> {
-    return new DoublyLinkedList(this.values());
+  clone(): DoublyLinkedList<E, R> {
+    return new DoublyLinkedList<E, R>(this);
   }
 
   /**
@@ -755,8 +751,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
    * elements that pass the filter condition specified by the `callback` function.
    */
-  filter(callback: ElementCallback<E, boolean>, thisArg?: any): DoublyLinkedList<E> {
-    const filteredList = new DoublyLinkedList<E>();
+  filter(callback: ElementCallback<E, R, boolean, DoublyLinkedList<E, R>>, thisArg?: any): DoublyLinkedList<E, R> {
+    const filteredList = new DoublyLinkedList<E, R>([], { toElementFn: this.toElementFn });
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
@@ -773,24 +769,28 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
-   * in the original list.
+   * The `map` function takes a callback function and returns a new DoublyLinkedList with the results
+   * of applying the callback to each element in the original list.
    * @param callback - The callback parameter is a function that will be called for each element in the
-   * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
-   * and the DoublyLinkedList itself. The callback function should return a value that will be added to
-   * the new DoublyLinkedList that
-   * @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 `DoublyLinkedList` object that contains the results
-   * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
-   * object.
-   */
-  map<T>(callback: ElementCallback<E, T>, thisArg?: any): DoublyLinkedList<T> {
-    const mappedList = new DoublyLinkedList<T>();
+   * original DoublyLinkedList. It takes three arguments: current (the current element being
+   * processed), index (the index of the current element), and this (the original DoublyLinkedList).
+   * The callback function should return a value of type
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+   * input and returns the converted element. If this parameter is not provided, the raw element will
+   * be used as 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 instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
+   */
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): DoublyLinkedList<EM, RM> {
+    const mappedList = new DoublyLinkedList<EM, RM>([], { toElementFn });
     let index = 0;
     for (const current of this) {
       mappedList.push(callback.call(thisArg, current, index, this));

package/src/data-structures/linked-list/singly-linked-list.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, SinglyLinkedListOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
 export class SinglyLinkedListNode<E = any> {
@@ -59,17 +59,17 @@ export class SinglyLinkedListNode<E = any> {
   }
 }
 
-export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
-  /**
-   * The constructor initializes a new instance of a class with an optional iterable of elements.
-   * @param elements - The `elements` parameter is an optional iterable object that contains the
-   * initial elements to be added to the instance of the class. If no `elements` are provided, an empty
-   * array will be used as the default value.
-   */
-  constructor(elements: Iterable<E> = []) {
-    super();
+export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: SinglyLinkedListOptions<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);
+        }
+      }
     }
   }
 
@@ -673,8 +673,8 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
    * is a clone of the original list.
    */
-  clone(): SinglyLinkedList<E> {
-    return new SinglyLinkedList<E>(this.values());
+  clone(): SinglyLinkedList<E, R> {
+    return new SinglyLinkedList<E, R>(this, { toElementFn: this.toElementFn });
   }
 
   /**
@@ -699,8 +699,8 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * @returns The `filter` method is returning a new `SinglyLinkedList` object that contains the
    * elements that pass the filter condition specified by the `callback` function.
    */
-  filter(callback: ElementCallback<E, boolean>, thisArg?: any): SinglyLinkedList<E> {
-    const filteredList = new SinglyLinkedList<E>();
+  filter(callback: ElementCallback<E, R, boolean, SinglyLinkedList<E, R>>, thisArg?: any): SinglyLinkedList<E, R> {
+    const filteredList = new SinglyLinkedList<E, R>([], { toElementFn: this.toElementFn });
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
@@ -715,22 +715,30 @@ export class SinglyLinkedList<E = any> 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 SinglyLinkedList by applying a callback function to each element
-   * of the original list.
+   * The `map` function takes a callback function and returns a new SinglyLinkedList with the results
+   * of applying the callback to each element in the original list.
    * @param callback - The `callback` parameter is a function that will be called for each element in
-   * the linked list. 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` function is returning a new `SinglyLinkedList` object that contains the results
-   * of applying the provided `callback` function to each element in the original list.
-   */
-  map<T>(callback: ElementCallback<E, T>, thisArg?: any): SinglyLinkedList<T> {
-    const mappedList = new SinglyLinkedList<T>();
+   * the original list. It takes three arguments: `current` (the current element being processed),
+   * `index` (the index of the current element), and `this` (the original list). It should return a
+   * value
+   * @param [toElementFn] - The `toElementFn` parameter is an optional function that can be used to
+   * convert the raw element (`RR`) to the desired element type (`T`). It takes the raw element as
+   * input and returns the converted element. If this parameter is not provided, the raw element will
+   * be used as 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 instance of the `SinglyLinkedList` class with the mapped elements.
+   */
+  map<EM, RM>(
+    callback: ElementCallback<E, R, EM, SinglyLinkedList<E, R>>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): SinglyLinkedList<EM, RM> {
+    const mappedList = new SinglyLinkedList<EM, RM>([], { toElementFn });
     let index = 0;
     for (const current of this) {
       mappedList.push(callback.call(thisArg, current, index, this));

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { PriorityQueueOptions } from '../../types';
+import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
-export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
+export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a
    * comparator function.
@@ -16,21 +16,102 @@ export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
    * elements to be added to the priority queue. It is optional and defaults to an empty array if not
    * provided.
    * @param options - The `options` parameter is an object that contains additional configuration
-   * options for the priority queue. In this case, it has a property called `comparator` which is a
+   * options for the priority queue. In this case, it has a property called `comparator,` which is a
    * function used to compare elements in the priority queue.
    */
-  constructor(
-    elements: Iterable<E> = [],
-    options: PriorityQueueOptions<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;
+  constructor(elements: Iterable<E> | Iterable<R> = [], options?: PriorityQueueOptions<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 `MaxPriorityQueue` class with the same
+   * comparator and toElementFn as the current instance.
+   * @returns The method is returning a new instance of the MaxPriorityQueue class with the same
+   * comparator and toElementFn as the current instance.
+   */
+  override clone(): MaxPriorityQueue<E, R> {
+    return new MaxPriorityQueue<E, R>(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new MaxPriorityQueue 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 `MaxPriorityQueue` object that contains the elements that pass
+   * the filter condition specified by the `callback` function.
+   */
+  override filter(
+    callback: ElementCallback<E, R, boolean, MaxPriorityQueue<E, R>>,
+    thisArg?: any
+  ): MaxPriorityQueue<E, R> {
+    const filteredPriorityQueue = new MaxPriorityQueue<E, R>([], {
+      toElementFn: this.toElementFn,
+      comparator: this.comparator
+    });
+    let index = 0;
+    for (const current of this) {
+      if (callback.call(thisArg, current, index, this)) {
+        filteredPriorityQueue.add(current);
       }
+      index++;
+    }
+    return filteredPriorityQueue;
+  }
+
+  /**
+   * 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 `MaxPriorityQueue` class with the mapped elements.
+   */
+  override map<EM, RM>(
+    callback: ElementCallback<E, R, EM, MaxPriorityQueue<E, R>>,
+    comparator: Comparator<EM>,
+    toElementFn?: (rawElement: RM) => EM,
+    thisArg?: any
+  ): MaxPriorityQueue<EM, RM> {
+    const mappedPriorityQueue = new MaxPriorityQueue<EM, RM>([], { comparator, toElementFn });
+    let index = 0;
+    for (const el of this) {
+      mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
+      index++;
     }
-  ) {
-    super(elements, options);
+    return mappedPriorityQueue;
   }
 }