queue-typed 1.48.1 → 1.48.2

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

@@ -1,3 +1,6 @@
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
+
 /**
  * data-structure-typed
  *
@@ -22,11 +25,12 @@ export class DoublyLinkedListNode<E = any> {
   }
 }
 
-export class DoublyLinkedList<E = any> {
+export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
   constructor(elements?: Iterable<E>) {
+    super();
     this._head = undefined;
     this._tail = undefined;
     this._length = 0;
@@ -724,59 +728,32 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * 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;
-    }
-  }
-
-  /**
-   * 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++;
-    }
-  }
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-   * elements that satisfy the given callback function.
-   * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-   * 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, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E> {
+   * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
+   * list and applying a callback function to each element, returning only the elements for which the
+   * callback function returns true.
+   * @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 boolean value
+   * indicating whether the current element should be included
+   * @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 `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>();
     let index = 0;
     for (const current of this) {
-      if (callback(current, index, this)) {
+      if (callback.call(thisArg, current, index, this)) {
         filteredList.push(current);
       }
       index++;
@@ -790,21 +767,27 @@ export class DoublyLinkedList<E = any> {
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * 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 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.
-   */
-  map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T> {
+   * The `map` function creates a new DoublyLinkedList by applying a callback function 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>();
     let index = 0;
     for (const current of this) {
-      mappedList.push(callback(current, index, this));
+      mappedList.push(callback.call(thisArg, current, index, this));
       index++;
     }
 
@@ -816,31 +799,19 @@ export class DoublyLinkedList<E = any> {
    * Space Complexity: O(n)
    */
 
-  /**
-   * 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 {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.
-   */
-  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 accumulator;
-  }
-
   print(): void {
     console.log([...this]);
   }
+
+  /**
+   * The function returns an iterator that iterates over the values of a linked list.
+   */
+  protected* _getIterator(): IterableIterator<E> {
+    let current = this.head;
+
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
 }

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

@@ -1,3 +1,6 @@
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
+
 /**
  * data-structure-typed
  *
@@ -20,11 +23,12 @@ export class SinglyLinkedListNode<E = any> {
   }
 }
 
-export class SinglyLinkedList<E = any> {
+export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
   constructor(elements?: Iterable<E>) {
+    super();
     this._head = undefined;
     this._tail = undefined;
     this._length = 0;
@@ -670,59 +674,32 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
-   * 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;
-    }
-  }
-
-  /**
-   * 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: SinglyLinkedList<E>) => void): void {
-    let index = 0;
-    for (const el of this) {
-      callback(el, index, this);
-      index++;
-    }
-  }
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
-   * elements that satisfy the given callback function.
-   * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-   * 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 SinglyLinkedList class.
-   */
-  filter(callback: (value: E, index: number, list: SinglyLinkedList<E>) => boolean): SinglyLinkedList<E> {
+   * The `filter` function creates a new SinglyLinkedList by iterating over the elements of the current
+   * list and applying a callback function to each element to determine if it should be included in the
+   * filtered list.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * list. It takes three arguments: the current element, the index of the current element, and the
+   * list itself. The callback function should return a boolean value indicating whether the current
+   * element should be included in the filtered list or not
+   * @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 `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>();
     let index = 0;
     for (const current of this) {
-      if (callback(current, index, this)) {
+      if (callback.call(thisArg, current, index, this)) {
         filteredList.push(current);
       }
       index++;
@@ -730,27 +707,30 @@ export class SinglyLinkedList<E = any> {
     return filteredList;
   }
 
+
   /**
    * 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.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
-   * SinglyLinkedList 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 SinglyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
-   * SinglyLinkedList).
-   * @returns The `map` function is returning a new instance of `SinglyLinkedList<T>` that contains the mapped values.
-   */
-  map<T>(callback: (value: E, index: number, list: SinglyLinkedList<E>) => T): SinglyLinkedList<T> {
+   * The `map` function creates a new SinglyLinkedList by applying a callback function to each element
+   * of 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>();
     let index = 0;
     for (const current of this) {
-      mappedList.push(callback(current, index, this));
+      mappedList.push(callback.call(thisArg, current, index, this));
       index++;
     }
 
@@ -762,31 +742,16 @@ export class SinglyLinkedList<E = any> {
    * Space Complexity: O(n)
    */
 
-  /**
-   * 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 {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.
-   */
-  reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const current of this) {
-      accumulator = callback(accumulator, current, index, this);
-      index++;
-    }
-
-    return accumulator;
-  }
-
   print(): void {
     console.log([...this]);
   }
+
+  protected* _getIterator(): IterableIterator<E> {
+    let current = this.head;
+
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
 }

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

@@ -7,8 +7,9 @@
  */
 
 
-import { IterableWithSizeOrLength } from "../../types";
+import { ElementCallback, IterableWithSizeOrLength } from "../../types";
 import { calcMinUnitsRequired, rangeCheck } from "../../utils";
+import { IterableElementBase } from "../base";
 
 /**
  * Deque can provide random access with O(1) time complexity
@@ -17,7 +18,7 @@ import { calcMinUnitsRequired, rangeCheck } from "../../utils";
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
 
-export class Deque<E> {
+export class Deque<E> extends IterableElementBase<E> {
   protected _bucketFirst = 0;
   protected _firstInBucket = 0;
   protected _bucketLast = 0;
@@ -35,7 +36,7 @@ export class Deque<E> {
    * stored in each bucket. It determines the size of each bucket in the data structure.
    */
   constructor(elements: IterableWithSizeOrLength<E> = [], bucketSize = (1 << 12)) {
-
+    super();
     let _size: number;
     if ('length' in elements) {
       if (elements.length instanceof Function) _size = elements.length(); else _size = elements.length;
@@ -699,67 +700,31 @@ export class Deque<E> {
     return arr;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The above function is an implementation of the iterator protocol in TypeScript, allowing the
-   * object to be iterated over using a for...of loop.
-   */
-  * [Symbol.iterator]() {
-    for (let i = 0; i < this.size; ++i) {
-      yield this.getAt(i);
-    }
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each element in a deque and applies a callback function to
-   * each element.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * deque. It takes three parameters:
-   */
-  forEach(callback: (element: E, index: number, deque: this) => void) {
-    let index = 0;
-    for (const el of this) {
-      callback(el, index, this);
-      index++;
-    }
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `filter` function creates a new deque containing only the elements that satisfy the given
-   * predicate function.
-   * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
-   * `index`, and `deque`.
-   * @returns The `filter` method is returning a new `Deque` object that contains only the elements
-   * that satisfy the given `predicate` function.
-   */
-  filter(predicate: (element: E, index: number, deque: this) => boolean): Deque<E> {
+   * The `filter` function creates a new deque containing elements from the original deque that satisfy
+   * a given predicate function.
+   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+   * the current element being iterated over, the index of the current element, and the deque itself.
+   * It should return a boolean value indicating whether the element should be included in the filtered
+   * deque or not.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `predicate` function. If `thisArg` is
+   * @returns The `filter` method is returning a new `Deque` object that contains the elements that
+   * satisfy the given predicate function.
+   */
+  filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E> {
     const newDeque = new Deque<E>([], this._bucketSize);
     let index = 0;
     for (const el of this) {
-      if (predicate(el, index, this)) {
+      if (predicate.call(thisArg, el, index, this)) {
         newDeque.push(el);
       }
       index++;
@@ -771,21 +736,24 @@ export class Deque<E> {
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `map` function takes a callback function and applies it to each element in the deque,
-   * returning a new deque with the results.
-   * @param callback - The `callback` parameter is a function that takes three arguments:
-   * @returns The `map` method is returning a new `Deque` object with the transformed elements.
-   */
-  map<T>(callback: (element: E, index: number, deque: this) => T): Deque<T> {
+   * The `map` function creates a new Deque by applying a callback function to each element of the
+   * original Deque.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the deque. It takes three arguments:
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `callback` function. If `thisArg` is
+   * @returns a new Deque object with the mapped values.
+   */
+  map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T> {
     const newDeque = new Deque<T>([], this._bucketSize);
     let index = 0;
     for (const el of this) {
-      newDeque.push(callback(el, index, this));
+      newDeque.push(callback.call(thisArg, el, index, this));
       index++;
     }
     return newDeque;
@@ -793,34 +761,24 @@ export class Deque<E> {
 
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
+  print(): void {
+    console.log([...this])
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * The `reduce` function iterates over the elements of a deque and applies a callback function to
-   * each element, accumulating a single value.
-   * @param callback - The `callback` parameter is a function that takes four arguments:
-   * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-   * is the value that will be passed as the first argument to the `callback` function when reducing
-   * the elements of the deque.
-   * @returns the final value of the accumulator after iterating over all elements in the deque and
-   * applying the callback function to each element.
-   */
-  reduce<T>(callback: (accumulator: T, element: E, index: number, deque: this) => T, initialValue: T): T {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const el of this) {
-      accumulator = callback(accumulator, el, index, this);
-      index++;
+   * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+   * object to be iterated over using a for...of loop.
+   */
+  protected* _getIterator() {
+    for (let i = 0; i < this.size; ++i) {
+      yield this.getAt(i);
     }
-    return accumulator;
-  }
-
-  print(): void {
-    console.log([...this])
   }
 
   /**