queue-typed 1.47.4 → 1.47.6

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -24,10 +24,14 @@ class SinglyLinkedList {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
         this._head = null;
         this._tail = null;
         this._length = 0;
+        if (elements) {
+            for (const el of elements)
+                this.push(el);
+        }
     }
     get head() {
         return this._head;
@@ -605,58 +609,42 @@ class SinglyLinkedList {
         return count;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     */
-    /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * Space Complexity: O(1) - Constant space.
-     *
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
+     * The function returns an iterator that iterates over the values of a linked list.
      */
-    forEach(callback) {
+    *[Symbol.iterator]() {
         let current = this.head;
-        let index = 0;
         while (current) {
-            callback(current.value, index);
+            yield current.value;
             current = current.next;
-            index++;
         }
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      *
-     * 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 U (the type of values that will be stored in the mapped
-     * SinglyLinkedList).
-     * @returns The `map` function is returning a new instance of `SinglyLinkedList<U>` that contains the mapped values.
+     * 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.
      */
-    map(callback) {
-        const mappedList = new SinglyLinkedList();
-        let current = this.head;
-        while (current) {
-            mappedList.push(callback(current.value));
-            current = current.next;
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
         }
-        return mappedList;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * 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.
@@ -666,50 +654,67 @@ class SinglyLinkedList {
      */
     filter(callback) {
         const filteredList = new SinglyLinkedList();
-        let current = this.head;
-        while (current) {
-            if (callback(current.value)) {
-                filteredList.push(current.value);
+        let index = 0;
+        for (const current of this) {
+            if (callback(current, index, this)) {
+                filteredList.push(current);
             }
-            current = current.next;
+            index++;
         }
         return filteredList;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
-     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     *
+     * The `map` function takes a callback function and applies it to each element in the 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(callback) {
+        const mappedList = new SinglyLinkedList();
+        let index = 0;
+        for (const current of this) {
+            mappedList.push(callback(current, index, this));
+            index++;
+        }
+        return mappedList;
+    }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(n)
      *
      * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
      * used to perform a specific operation on each element of the linked list.
-     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * @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(callback, initialValue) {
         let accumulator = initialValue;
-        let current = this.head;
-        while (current) {
-            accumulator = callback(accumulator, current.value);
-            current = current.next;
+        let index = 0;
+        for (const current of this) {
+            accumulator = callback(accumulator, current, index, this);
+            index++;
         }
         return accumulator;
     }
-    /**
-     * 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;
-        }
+    print() {
+        console.log([...this]);
     }
 }
 exports.SinglyLinkedList = SinglyLinkedList;

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -6,10 +6,7 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(options?: {
-        comparator: Comparator<E>;
-        nodes?: E[];
-    });
+    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -10,7 +10,7 @@ exports.MaxPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
@@ -20,7 +20,7 @@ class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }
 exports.MaxPriorityQueue = MaxPriorityQueue;

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -6,10 +6,7 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { Comparator } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(options?: {
-        comparator: Comparator<E>;
-        nodes?: E[];
-    });
+    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -10,7 +10,7 @@ exports.MinPriorityQueue = void 0;
  */
 const priority_queue_1 = require("./priority-queue");
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
@@ -20,7 +20,7 @@ class MinPriorityQueue extends priority_queue_1.PriorityQueue {
             }
         }
     }) {
-        super(options);
+        super(elements, options);
     }
 }
 exports.MinPriorityQueue = MinPriorityQueue;

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -6,10 +6,7 @@
  * @license MIT License
  */
 import { Heap } from '../heap';
-import { Comparator } from '../../types';
+import { PriorityQueueOptions } from '../../types';
 export declare class PriorityQueue<E = any> extends Heap<E> {
-    constructor(options: {
-        comparator: Comparator<E>;
-        nodes?: E[];
-    });
+    constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

package/dist/data-structures/priority-queue/priority-queue.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
 const heap_1 = require("../heap");
 class PriorityQueue extends heap_1.Heap {
-    constructor(options) {
-        super(options);
+    constructor(elements, options) {
+        super(elements, options);
     }
 }
 exports.PriorityQueue = PriorityQueue;

package/dist/data-structures/queue/deque.d.ts

@@ -318,12 +318,14 @@ export declare class Deque<E> {
      * 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:
+     * The `find` function iterates over the elements in a deque and returns the first element for which
+     * the callback function returns true, or undefined if no such element is found.
+     * @param callback - A function that takes three parameters: element, index, and deque. It should
+     * return a boolean value indicating whether the element satisfies a certain condition.
+     * @returns The method `find` returns the first element in the deque that satisfies the condition
+     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
      */
-    forEach(callback: (element: E, index: number, deque: Deque<E>) => void): void;
+    find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -332,14 +334,14 @@ export declare class Deque<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
+     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
+     * or -1 if the element is not found.
+     * @param {E} element - The "element" parameter represents the element that you want to find the
+     * index of in the data structure.
+     * @returns The indexOf function returns the index of the first occurrence of the specified element
+     * in the data structure. If the element is not found, it returns -1.
      */
-    find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined;
+    indexOf(element: E): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -354,18 +356,30 @@ export declare class Deque<E> {
     toArray(): E[];
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * 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 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](): Generator<E, void, unknown>;
+    /**
+     * 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:
      */
-    map<T>(callback: (element: E, index: number, deque: Deque<E>) => T): Deque<T>;
+    forEach(callback: (element: E, index: number, deque: this) => void): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -381,7 +395,21 @@ export declare class Deque<E> {
      * @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: Deque<E>) => boolean): Deque<E>;
+    filter(predicate: (element: E, index: number, deque: this) => boolean): 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>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -399,35 +427,8 @@ export declare class Deque<E> {
      * @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: Deque<E>) => T, initialValue: T): T;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-     * or -1 if the element is not found.
-     * @param {E} element - The "element" parameter represents the element that you want to find the
-     * index of in the data structure.
-     * @returns The indexOf function returns the index of the first occurrence of the specified element
-     * in the data structure. If the element is not found, it returns -1.
-     */
-    indexOf(element: E): number;
-    /**
-     * 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](): Generator<E, void, unknown>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, deque: this) => T, initialValue: T): T;
+    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/queue/deque.js

@@ -594,15 +594,21 @@ class Deque {
      * 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:
+     * The `find` function iterates over the elements in a deque and returns the first element for which
+     * the callback function returns true, or undefined if no such element is found.
+     * @param callback - A function that takes three parameters: element, index, and deque. It should
+     * return a boolean value indicating whether the element satisfies a certain condition.
+     * @returns The method `find` returns the first element in the deque that satisfies the condition
+     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
      */
-    forEach(callback) {
+    find(callback) {
         for (let i = 0; i < this.size; ++i) {
-            callback(this.getAt(i), i, this);
+            const element = this.getAt(i);
+            if (callback(element, i, this)) {
+                return element;
+            }
         }
+        return undefined;
     }
     /**
      * Time Complexity: O(n)
@@ -612,21 +618,20 @@ class Deque {
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
+     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
+     * or -1 if the element is not found.
+     * @param {E} element - The "element" parameter represents the element that you want to find the
+     * index of in the data structure.
+     * @returns The indexOf function returns the index of the first occurrence of the specified element
+     * in the data structure. If the element is not found, it returns -1.
      */
-    find(callback) {
+    indexOf(element) {
         for (let i = 0; i < this.size; ++i) {
-            const element = this.getAt(i);
-            if (callback(element, i, this)) {
-                return element;
+            if (this.getAt(i) === element) {
+                return i;
             }
         }
-        return undefined;
+        return -1;
     }
     /**
      * Time Complexity: O(n)
@@ -648,23 +653,39 @@ class Deque {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      *
-     * 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 above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
      */
-    map(callback) {
-        const newDeque = new Deque([], this._bucketSize);
+    *[Symbol.iterator]() {
         for (let i = 0; i < this.size; ++i) {
-            newDeque.push(callback(this.getAt(i), i, this));
+            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) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
         }
-        return newDeque;
     }
     /**
      * Time Complexity: O(n)
@@ -683,11 +704,34 @@ class Deque {
      */
     filter(predicate) {
         const newDeque = new Deque([], this._bucketSize);
-        for (let i = 0; i < this.size; ++i) {
-            const element = this.getAt(i);
-            if (predicate(element, i, this)) {
-                newDeque.push(element);
+        let index = 0;
+        for (const el of this) {
+            if (predicate(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 `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(callback) {
+        const newDeque = new Deque([], this._bucketSize);
+        let index = 0;
+        for (const el of this) {
+            newDeque.push(callback(el, index, this));
+            index++;
         }
         return newDeque;
     }
@@ -710,49 +754,15 @@ class Deque {
      */
     reduce(callback, initialValue) {
         let accumulator = initialValue;
-        for (let i = 0; i < this.size; ++i) {
-            accumulator = callback(accumulator, this.getAt(i), i, this);
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
         }
         return accumulator;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-     * or -1 if the element is not found.
-     * @param {E} element - The "element" parameter represents the element that you want to find the
-     * index of in the data structure.
-     * @returns The indexOf function returns the index of the first occurrence of the specified element
-     * in the data structure. If the element is not found, it returns -1.
-     */
-    indexOf(element) {
-        for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    /**
-     * 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);
-        }
+    print() {
+        console.log([...this]);
     }
     /**
      * Time Complexity: O(n)