avl-tree-typed 1.47.4 → 1.47.5

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

@@ -666,63 +666,47 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
-   * 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: (value: E, index: number) => void): void {
+  * [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<U>(callback: (value: E) => U): SinglyLinkedList<U> {
-    const mappedList = new SinglyLinkedList<U>();
-    let current = this.head;
-    while (current) {
-      mappedList.push(callback(current.value));
-      current = current.next;
+  forEach(callback: (value: E, index: number, list: SinglyLinkedList<E>) => void): void {
+    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.
@@ -730,55 +714,71 @@ export class SinglyLinkedList<E = any> {
    * 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) => boolean): SinglyLinkedList<E> {
+  filter(callback: (value: E, index: number, list: SinglyLinkedList<E>) => boolean): SinglyLinkedList<E> {
     const filteredList = new SinglyLinkedList<E>();
-    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), 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<T>(callback: (value: E, index: number, list: SinglyLinkedList<E>) => T): SinglyLinkedList<T> {
+    const mappedList = new SinglyLinkedList<T>();
+    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) - 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 `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<U>(callback: (accumulator: U, value: E) => U, initialValue: U): U {
+  reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T {
     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;
-    }
+    return accumulator;
   }
 }

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

@@ -637,15 +637,21 @@ export 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) {
+  find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined {
     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;
   }
 
   /**
@@ -657,21 +663,20 @@ export 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 {
     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;
   }
 
   /**
@@ -696,102 +701,94 @@ export class Deque<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.
    */
-  map<T>(callback: (element: E, index: number, deque: Deque<E>) => T): Deque<T> {
-    const newDeque = new Deque<T>([], this._bucketSize);
+  * [Symbol.iterator]() {
     for (let i = 0; i < this.size; ++i) {
-      newDeque.push(callback(this.getAt(i), i, this));
+      yield this.getAt(i);
     }
-    return newDeque;
   }
 
   /**
    * 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 `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.
+   * 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:
    */
-  filter(predicate: (element: E, index: number, deque: Deque<E>) => boolean): Deque<E> {
-    const newDeque = new Deque<E>([], this._bucketSize);
-    for (let i = 0; i < this.size; ++i) {
-      const element = this.getAt(i);
-      if (predicate(element, i, this)) {
-        newDeque.push(element);
-      }
+  forEach(callback: (element: E, index: number, deque: this) => void) {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
     }
-    return newDeque;
   }
 
   /**
    * 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 `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 `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.
    */
-  reduce<T>(callback: (accumulator: T, element: E, index: number, deque: Deque<E>) => T, initialValue: T): T {
-    let accumulator = initialValue;
-    for (let i = 0; i < this.size; ++i) {
-      accumulator = callback(accumulator, this.getAt(i), i, this);
+  filter(predicate: (element: E, index: number, deque: this) => boolean): Deque<E> {
+    const newDeque = new Deque<E>([], this._bucketSize);
+    let index = 0;
+    for (const el of this) {
+      if (predicate(el, index, this)) {
+        newDeque.push(el);
+      }
+      index++;
     }
-    return accumulator;
+    return newDeque;
   }
 
   /**
    * 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 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.
+   * 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.
    */
-  indexOf(element: E): number {
-    for (let i = 0; i < this.size; ++i) {
-      if (this.getAt(i) === element) {
-        return i;
-      }
+  map<T>(callback: (element: E, index: number, deque: this) => T): Deque<T> {
+    const newDeque = new Deque<T>([], this._bucketSize);
+    let index = 0;
+    for (const el of this) {
+      newDeque.push(callback(el, index, this));
+      index++;
     }
-    return -1;
+    return newDeque;
   }
 
   /**
@@ -803,13 +800,23 @@ export class Deque<E> {
    * 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.
+   * 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.
    */
-  * [Symbol.iterator]() {
-    for (let i = 0; i < this.size; ++i) {
-      yield this.getAt(i);
+  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++;
     }
+    return accumulator;
   }
 
   /**

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

@@ -305,4 +305,88 @@ export class Queue<E = any> {
       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: (element: E, index: number, queue: 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 `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>([]);
+    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<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;
+  }
+
+  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;
+  }
 }

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

@@ -25,6 +25,14 @@ export class Stack<E = any> {
    * 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 {
+    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.
@@ -46,14 +54,6 @@ export class Stack<E = any> {
     return this.elements.length === 0;
   }
 
-  /**
-   * The size() function returns the number of elements in an array.
-   * @returns The size of the elements array.
-   */
-  size(): number {
-    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.
@@ -147,4 +147,60 @@ export class Stack<E = any> {
   clone(): Stack<E> {
     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: (element: E, index: number, stack: this) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
+    }
+  }
+
+
+  filter(predicate: (element: E, index: number, stack: this) => boolean): Stack<E> {
+    const newStack = new Stack<E>();
+    let index = 0;
+    for (const el of this) {
+      if (predicate(el, index, this)) {
+        newStack.push(el);
+      }
+      index++;
+    }
+    return newStack;
+  }
+
+
+  map<T>(callback: (element: E, index: number, stack: this) => T): Stack<T> {
+    const newStack = new Stack<T>();
+    let index = 0;
+    for (const el of this) {
+      newStack.push(callback(el, index, this));
+      index++;
+    }
+    return newStack;
+  }
+
+  reduce<T>(callback: (accumulator: T, element: E, index: number, stack: 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;
+  }
 }

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

@@ -324,6 +324,59 @@ export class Trie {
     return words;
   }
 
+  * [Symbol.iterator](): IterableIterator<string> {
+    function* _dfs(node: TrieNode, path: string): IterableIterator<string> {
+      if (node.isEnd) {
+        yield path;
+      }
+      for (const [char, childNode] of node.children) {
+        yield* _dfs(childNode, path + char);
+      }
+    }
+
+    yield* _dfs(this.root, '');
+  }
+
+  forEach(callback: (word: string, index: number, trie: this) => void): void {
+    let index = 0;
+    for (const word of this) {
+      callback(word, index, this);
+      index++;
+    }
+  }
+
+  filter(predicate: (word: string, index: number, trie: this) => boolean): string[] {
+    const results: string[] = [];
+    let index = 0;
+    for (const word of this) {
+      if (predicate(word, index, this)) {
+        results.push(word);
+      }
+      index++;
+    }
+    return results;
+  }
+
+  map(callback: (word: string, index: number, trie: this) => string): Trie {
+    const newTrie = new Trie();
+    let index = 0;
+    for (const word of this) {
+      newTrie.add(callback(word, index, this));
+      index++;
+    }
+    return newTrie;
+  }
+
+  reduce<T>(callback: (accumulator: T, word: string, index: number, trie: this) => T, initialValue: T): T {
+    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.