directed-graph-typed 1.48.0 → 1.49.0

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;
@@ -119,10 +120,10 @@ export class Deque<E> {
    * Time Complexity: O(1) - Removes the last element.
    * Space Complexity: O(1) - Operates in-place.
    *
-   * The function "popLast" removes and returns the last element of an array.
+   * The function "pollLast" removes and returns the last element of an array.
    * @returns The last element of the array is being returned.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -142,11 +143,11 @@ export class Deque<E> {
    * Time Complexity: O(1) - Removes the first element.
    * Space Complexity: O(1) - In-place operation.
    *
-   * The function "popFirst" removes and returns the first element of an array.
-   * @returns The method `popFirst()` is returning the first element of the array after removing it
+   * The function "pollFirst" removes and returns the first element of an array.
+   * @returns The method `pollFirst()` is returning the first element of the array after removing it
    * from the beginning. If the array is empty, it will return `undefined`.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 
@@ -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.
+   * 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: (element: E, index: number, deque: this) => T): Deque<T> {
+  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.
+   * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+   * object to be iterated over using a for...of loop.
    */
-  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++;
+  protected* _getIterator() {
+    for (let i = 0; i < this.size; ++i) {
+      yield this.getAt(i);
     }
-    return accumulator;
-  }
-
-  print(): void {
-    console.log([...this])
   }
 
   /**
@@ -891,194 +849,4 @@ export class Deque<E> {
 
     return { bucketIndex, indexInBucket };
   }
-}
-
-// O(1) time complexity of obtaining the element
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-export class ObjectDeque<E = number> {
-  constructor(capacity?: number) {
-    if (capacity !== undefined) this._capacity = capacity;
-  }
-
-  protected _nodes: { [key: number]: E } = {};
-
-  get nodes(): { [p: number]: E } {
-    return this._nodes;
-  }
-
-  protected _capacity = Number.MAX_SAFE_INTEGER;
-
-  get capacity(): number {
-    return this._capacity;
-  }
-
-  protected _first = -1;
-
-  get first(): number {
-    return this._first;
-  }
-
-  protected _last = -1;
-
-  get last(): number {
-    return this._last;
-  }
-
-  protected _size = 0;
-
-  get size(): number {
-    return this._size;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The "addFirst" function adds an element to the beginning of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
-   * structure.
-   */
-  addFirst(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._first--;
-    }
-    this.nodes[this.first] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The addLast function adds an element to the end of an array-like data structure.
-   * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
-   */
-  addLast(element: E) {
-    if (this.size === 0) {
-      const mid = Math.floor(this.capacity / 2);
-      this._first = mid;
-      this._last = mid;
-    } else {
-      this._last++;
-    }
-    this.nodes[this.last] = element;
-    this._size++;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `popFirst()` removes and returns the first element in a data structure.
-   * @returns The element of the first element in the data structure.
-   */
-  popFirst() {
-    if (!this.size) return;
-    const element = this.getFirst();
-    delete this.nodes[this.first];
-    this._first++;
-    this._size--;
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getFirst` function returns the first element in an array-like data structure if it exists.
-   * @returns The element at the first position of the `_nodes` array.
-   */
-  getFirst() {
-    if (this.size) return this.nodes[this.first];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `popLast()` function removes and returns the last element in a data structure.
-   * @returns The element that was removed from the data structure.
-   */
-  popLast() {
-    if (!this.size) return;
-    const element = this.getLast();
-    delete this.nodes[this.last];
-    this._last--;
-    this._size--;
-
-    return element;
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `getLast()` function returns the last element in an array-like data structure.
-   * @returns The last element in the array "_nodes" is being returned.
-   */
-  getLast() {
-    if (this.size) return this.nodes[this.last];
-  }
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The get function returns the element at the specified index in an array-like data structure.
-   * @param {number} index - The index parameter is a number that represents the position of the element you want to
-   * retrieve from the array.
-   * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-   * index, `undefined` is returned.
-   */
-  get(index: number) {
-    return this.nodes[this.first + index] || undefined;
-  }
-
-  /**
-   * The function checks if the size of a data structure is less than or equal to zero.
-   * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
-   */
-  isEmpty() {
-    return this.size <= 0;
-  }
 }

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

@@ -4,42 +4,10 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
 
-export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
-  /**
-   * The enqueue function adds a value to the end of an array.
-   * @param {E} value - The value parameter represents the value that you want to add to the queue.
-   */
-  enqueue(value: E) {
-    this.push(value);
-  }
-
-  /**
-   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-   * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-   */
-  dequeue(): E | undefined {
-    return this.shift();
-  }
-
-  /**
-   * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  getFirst(): E | undefined {
-    return this.head?.value;
-  }
-
-  /**
-   * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-   * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-   */
-  peek(): E | undefined {
-    return this.getFirst();
-  }
-}
-
-export class Queue<E = any> {
+export class Queue<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
    * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
@@ -47,6 +15,7 @@ export class Queue<E = any> {
    * initialized as an empty array.
    */
   constructor(elements?: E[]) {
+    super();
     this._nodes = elements || [];
     this._offset = 0;
   }
@@ -304,57 +273,62 @@ export class Queue<E = any> {
     console.log([...this]);
   }
 
-  * [Symbol.iterator]() {
-    for (const item of this.nodes) {
-      yield item;
-    }
-  }
-
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    */
 
   /**
    * Time Complexity: O(n)
-   * Space Complexity: O(1)
+   * Space Complexity: O(n)
    *
-   * 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, queue: this) => void) {
+   * The `filter` function creates a new `Queue` object containing elements from the original `Queue`
+   * 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 queue itself.
+   * It should return a boolean value indicating whether the element should be included in the filtered
+   * queue 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 `Queue` object that contains the elements that
+   * satisfy the given predicate function.
+   */
+  filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Queue<E> {
+    const newDeque = new Queue<E>([]);
     let index = 0;
     for (const el of this) {
-      callback(el, index, this);
+      if (predicate.call(thisArg, el, index, this)) {
+        newDeque.push(el);
+      }
       index++;
     }
+    return newDeque;
   }
 
   /**
    * 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 `Queue` object that contains only the elements
-   * that satisfy the given `predicate` function.
-   */
-  filter(predicate: (element: E, index: number, queue: this) => boolean): Queue<E> {
-    const newDeque = new Queue<E>([]);
+   * The `map` function takes a callback function and applies it to each element in the queue,
+   * returning a new queue with the results.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * queue. It takes three arguments: the current element, the index of the current element, and the
+   * queue itself. The callback function should return a new value that will be added to the new queue.
+   * @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 `Queue` object with the transformed elements.
+   */
+  map<T>(callback: ElementCallback<E, T>, thisArg?: any): Queue<T> {
+    const newDeque = new Queue<T>([]);
     let index = 0;
     for (const el of this) {
-      if (predicate(el, index, this)) {
-        newDeque.push(el);
-      }
+      newDeque.push(callback.call(thisArg, el, index, this));
       index++;
     }
     return newDeque;
@@ -365,32 +339,43 @@ export class Queue<E = any> {
    * Space Complexity: O(n)
    */
 
+  protected* _getIterator() {
+    for (const item of this.nodes) {
+      yield item;
+    }
+  }
+}
+
+export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   /**
-   * 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 `Queue` object with the transformed elements.
+   * The enqueue function adds a value to the end of an array.
+   * @param {E} value - The value parameter represents the value that you want to add to the queue.
    */
-  map<T>(callback: (element: E, index: number, queue: this) => T): Queue<T> {
-    const newDeque = new Queue<T>([]);
-    let index = 0;
-    for (const el of this) {
-      newDeque.push(callback(el, index, this));
-      index++;
-    }
-    return newDeque;
+  enqueue(value: E) {
+    this.push(value);
   }
 
-  reduce<T>(callback: (accumulator: T, element: E, index: number, queue: this) => T, initialValue: T): T {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const el of this) {
-      accumulator = callback(accumulator, el, index, this);
-      index++;
-    }
-    return accumulator;
+  /**
+   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+   * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
+   */
+  dequeue(): E | undefined {
+    return this.shift();
+  }
+
+  /**
+   * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+   * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+   */
+  getFirst(): E | undefined {
+    return this.head?.value;
+  }
+
+  /**
+   * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+   * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+   */
+  peek(): E | undefined {
+    return this.getFirst();
   }
 }