data-structure-typed 1.47.4 → 1.47.5

package/dist/mjs/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,7 @@ 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;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -592,15 +592,21 @@ export 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)
@@ -610,21 +616,20 @@ export 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)
@@ -646,23 +651,39 @@ export 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)
@@ -681,11 +702,34 @@ export 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;
     }
@@ -708,50 +752,13 @@ export 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);
-        }
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -206,4 +206,49 @@ export declare class Queue<E = any> {
      */
     clone(): Queue<E>;
     [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:
+     */
+    forEach(callback: (element: E, index: number, queue: this) => void): void;
+    /**
+     * 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>;
+    /**
+     * 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 `Queue` object with the transformed elements.
+     */
+    map<T>(callback: (element: E, index: number, queue: this) => T): Queue<T>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, queue: this) => T, initialValue: T): T;
 }

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

@@ -267,4 +267,81 @@ export class Queue {
             yield item;
         }
     }
+    /**
+     * 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++;
+        }
+    }
+    /**
+     * 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) {
+        const newDeque = new Queue([]);
+        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 `Queue` object with the transformed elements.
+     */
+    map(callback) {
+        const newDeque = new Queue([]);
+        let index = 0;
+        for (const el of this) {
+            newDeque.push(callback(el, index, this));
+            index++;
+        }
+        return newDeque;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
 }

package/dist/mjs/data-structures/stack/stack.d.ts

@@ -17,6 +17,11 @@ export declare class Stack<E = any> {
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
      */
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    get size(): number;
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
@@ -32,11 +37,6 @@ export declare class Stack<E = any> {
      * @returns A boolean value indicating whether the `_elements` array is empty or not.
      */
     isEmpty(): boolean;
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size(): number;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -103,4 +103,17 @@ export declare class Stack<E = any> {
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */
     clone(): Stack<E>;
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    [Symbol.iterator](): Generator<E, void, unknown>;
+    /**
+     * Applies a function to each element of the stack.
+     * @param {function(E): void} callback - A function to apply to each element.
+     */
+    forEach(callback: (element: E, index: number, stack: this) => void): void;
+    filter(predicate: (element: E, index: number, stack: this) => boolean): Stack<E>;
+    map<T>(callback: (element: E, index: number, stack: this) => T): Stack<T>;
+    reduce<T>(callback: (accumulator: T, element: E, index: number, stack: this) => T, initialValue: T): T;
 }

package/dist/mjs/data-structures/stack/stack.js

@@ -21,6 +21,13 @@ export class Stack {
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
      */
+    /**
+     * The size() function returns the number of elements in an array.
+     * @returns The size of the elements array.
+     */
+    get size() {
+        return this.elements.length;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
      * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
@@ -40,13 +47,6 @@ export class Stack {
     isEmpty() {
         return this.elements.length === 0;
     }
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size() {
-        return this.elements.length;
-    }
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -130,4 +130,53 @@ export class Stack {
     clone() {
         return new Stack(this.elements.slice());
     }
+    /**
+     * Custom iterator for the Stack class.
+     * @returns An iterator object.
+     */
+    *[Symbol.iterator]() {
+        for (let i = this.elements.length - 1; i >= 0; i--) {
+            yield this.elements[i];
+        }
+    }
+    /**
+     * Applies a function to each element of the stack.
+     * @param {function(E): void} callback - A function to apply to each element.
+     */
+    forEach(callback) {
+        let index = 0;
+        for (const el of this) {
+            callback(el, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const newStack = new Stack();
+        let index = 0;
+        for (const el of this) {
+            if (predicate(el, index, this)) {
+                newStack.push(el);
+            }
+            index++;
+        }
+        return newStack;
+    }
+    map(callback) {
+        const newStack = new Stack();
+        let index = 0;
+        for (const el of this) {
+            newStack.push(callback(el, index, this));
+            index++;
+        }
+        return newStack;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const el of this) {
+            accumulator = callback(accumulator, el, index, this);
+            index++;
+        }
+        return accumulator;
+    }
 }

package/dist/mjs/data-structures/trie/trie.d.ts

@@ -140,6 +140,11 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    [Symbol.iterator](): IterableIterator<string>;
+    forEach(callback: (word: string, index: number, trie: this) => void): void;
+    filter(predicate: (word: string, index: number, trie: this) => boolean): string[];
+    map(callback: (word: string, index: number, trie: this) => string): Trie;
+    reduce<T>(callback: (accumulator: T, word: string, index: number, trie: this) => T, initialValue: T): T;
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/mjs/data-structures/trie/trie.js

@@ -306,6 +306,53 @@ export class Trie {
             dfs(startNode, prefix);
         return words;
     }
+    *[Symbol.iterator]() {
+        function* _dfs(node, path) {
+            if (node.isEnd) {
+                yield path;
+            }
+            for (const [char, childNode] of node.children) {
+                yield* _dfs(childNode, path + char);
+            }
+        }
+        yield* _dfs(this.root, '');
+    }
+    forEach(callback) {
+        let index = 0;
+        for (const word of this) {
+            callback(word, index, this);
+            index++;
+        }
+    }
+    filter(predicate) {
+        const results = [];
+        let index = 0;
+        for (const word of this) {
+            if (predicate(word, index, this)) {
+                results.push(word);
+            }
+            index++;
+        }
+        return results;
+    }
+    map(callback) {
+        const newTrie = new Trie();
+        let index = 0;
+        for (const word of this) {
+            newTrie.add(callback(word, index, this));
+            index++;
+        }
+        return newTrie;
+    }
+    reduce(callback, initialValue) {
+        let accumulator = initialValue;
+        let index = 0;
+        for (const word of this) {
+            accumulator = callback(accumulator, word, index, this);
+            index++;
+        }
+        return accumulator;
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.