min-heap-typed 1.47.4 → 1.47.6

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,24 +701,42 @@ 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);
+    }
+  }
+
+  /**
+   * 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++;
     }
-    return newDeque;
   }
 
   /**
@@ -732,41 +755,40 @@ export 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> {
     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);
+    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(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 `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.
    */
-  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);
+  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 accumulator;
+    return newDeque;
   }
 
   /**
@@ -778,38 +800,27 @@ export class Deque<E> {
    * 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.
+   * 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.
    */
-  indexOf(element: E): number {
-    for (let i = 0; i < this.size; ++i) {
-      if (this.getAt(i) === element) {
-        return 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 -1;
+    return accumulator;
   }
 
-  /**
-   * 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(): void {
+    console.log([...this])
   }
 
   /**

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

@@ -300,9 +300,97 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
+  print(): void {
+    console.log([...this]);
+  }
+
   * [Symbol.iterator]() {
     for (const item of this.nodes) {
       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

@@ -10,8 +10,13 @@ export class Stack<E = any> {
    * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
    * is provided and is an array, it is assigned to the `_elements
    */
-  constructor(elements?: E[]) {
-    this._elements = Array.isArray(elements) ? elements : [];
+  constructor(elements?: Iterable<E>) {
+    this._elements = [];
+    if (elements) {
+      for (const el of elements) {
+        this.push(el);
+      }
+    }
   }
 
   protected _elements: E[];
@@ -25,6 +30,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 +59,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 +152,64 @@ 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 = 0; i < this.elements.length; 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;
+  }
+
+  print(): void {
+    console.log([...this]);
+  }
 }

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.

package/src/interfaces/binary-tree.ts

@@ -1,9 +1,21 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNested, BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey } from '../types';
+import {
+  BinaryTreeNested,
+  BinaryTreeNodeNested,
+  BinaryTreeOptions,
+  BiTreeDeleteResult,
+  BTNCallback,
+  BTNKey,
+  IterableEntriesOrKeys
+} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
   createNode(key: BTNKey, value?: N['value']): N;
 
+  createTree(options?: Partial<BinaryTreeOptions>): TREE;
+
+  init(elements: IterableEntriesOrKeys<V>): void;
+
   add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];

package/src/types/common.ts

@@ -1,3 +1,5 @@
+import { BTNKey } from "./data-structures";
+
 export type Comparator<T> = (a: T, b: T) => number;
 
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
@@ -20,4 +22,6 @@ export interface IterableWithLength<T> extends Iterable<T> {
 
 export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>
 
-export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
+export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
+
+export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -30,6 +30,6 @@ export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, Binary
 
 export type BinaryTreeNested<T, N extends BinaryTreeNode<T, N>> = BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, BinaryTree<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BinaryTreeOptions = { iterationType?: IterationType }
+export type BinaryTreeOptions = { iterationType: IterationType }
 
 export type NodeDisplayLayout = [string[], number, number, number];

package/src/types/data-structures/binary-tree/bst.ts

@@ -1,7 +1,6 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions, BTNKey } from './binary-tree';
-
-export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
+import { Comparator } from "../../common";
 
 // prettier-ignore
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
@@ -9,5 +8,5 @@ export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNo
 export type BSTNested<T, N extends BSTNode<T, N>> = BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, BST<T, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions = BinaryTreeOptions & {
-  comparator?: BSTComparator,
+  comparator: Comparator<BTNKey>
 }

package/src/types/data-structures/heap/heap.ts

@@ -1 +1,3 @@
-export {};
+import { Comparator } from "../../common";
+
+export type HeapOptions<T> = { comparator: Comparator<T> }

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

@@ -1 +1,3 @@
-export {};
+import { HeapOptions } from "../heap";
+
+export type PriorityQueueOptions<T> = HeapOptions<T> & {}