stack-typed 1.47.4 → 1.47.6

package/src/data-structures/hash/hash-table.ts

@@ -9,18 +9,18 @@
 export class HashTableNode<K, V> {
   key: K;
   value: V;
-  next: HashTableNode<K, V> | null;
+  next: HashTableNode<K, V> | undefined;
 
   constructor(key: K, value: V) {
     this.key = key;
     this.value = value;
-    this.next = null;
+    this.next = undefined;
   }
 }
 
 import { HashFunction } from '../../types';
 
-export class HashTable<K, V> {
+export class HashTable<K = any, V = any> {
   protected static readonly DEFAULT_CAPACITY = 16;
   protected static readonly LOAD_FACTOR = 0.75;
 
@@ -28,7 +28,7 @@ export class HashTable<K, V> {
     this._hashFn = hashFn || this._defaultHashFn;
     this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
     this._size = 0;
-    this._buckets = new Array<HashTableNode<K, V> | null>(this._capacity).fill(null);
+    this._buckets = new Array<HashTableNode<K, V> | undefined>(this._capacity).fill(undefined);
   }
 
   protected _capacity: number;
@@ -43,9 +43,9 @@ export class HashTable<K, V> {
     return this._size;
   }
 
-  protected _buckets: Array<HashTableNode<K, V> | null>;
+  protected _buckets: Array<HashTableNode<K, V> | undefined>;
 
-  get buckets(): Array<HashTableNode<K, V> | null> {
+  get buckets(): Array<HashTableNode<K, V> | undefined> {
     return this._buckets;
   }
 
@@ -125,7 +125,7 @@ export class HashTable<K, V> {
   delete(key: K): void {
     const index = this._hash(key);
     let currentNode = this._buckets[index];
-    let prevNode: HashTableNode<K, V> | null = null;
+    let prevNode: HashTableNode<K, V> | undefined = undefined;
 
     while (currentNode) {
       if (currentNode.key === key) {
@@ -135,7 +135,7 @@ export class HashTable<K, V> {
           this._buckets[index] = currentNode.next;
         }
         this._size--;
-        currentNode.next = null; // Release memory
+        currentNode.next = undefined; // Release memory
         return;
       }
       prevNode = currentNode;
@@ -143,6 +143,56 @@ export class HashTable<K, V> {
     }
   }
 
+  * [Symbol.iterator](): Generator<[K, V], void, undefined> {
+    for (const bucket of this._buckets) {
+      let currentNode = bucket;
+      while (currentNode) {
+        yield [currentNode.key, currentNode.value];
+        currentNode = currentNode.next;
+      }
+    }
+  }
+
+  forEach(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => void): void {
+    let index = 0;
+    for (const entry of this) {
+      callback(entry, index, this);
+      index++;
+    }
+  }
+
+  filter(predicate: (entry: [K, V], index: number, table: HashTable<K, V>) => boolean): HashTable<K, V> {
+    const newTable = new HashTable<K, V>();
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate([key, value], index, this)) {
+        newTable.set(key, value);
+      }
+      index++;
+    }
+    return newTable;
+  }
+
+  map<T>(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => T): HashTable<K, T> {
+    const newTable = new HashTable<K, T>();
+    let index = 0;
+    for (const [key, value] of this) {
+      newTable.set(key, callback([key, value], index, this));
+      index++;
+    }
+    return newTable;
+  }
+
+  reduce<T>(callback: (accumulator: T, entry: [K, V], index: number, table: HashTable<K, V>) => T, initialValue: T): T {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const entry of this) {
+      accumulator = callback(accumulator, entry, index, this);
+      index++;
+    }
+    return accumulator;
+  }
+
   /**
    * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
    * capacity of the data structure.
@@ -241,7 +291,7 @@ export class HashTable<K, V> {
    */
   protected _expand(): void {
     const newCapacity = this._capacity * 2;
-    const newBuckets = new Array<HashTableNode<K, V> | null>(newCapacity).fill(null);
+    const newBuckets = new Array<HashTableNode<K, V> | undefined>(newCapacity).fill(undefined);
 
     for (const bucket of this._buckets) {
       let currentNode = bucket;

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

@@ -6,13 +6,32 @@
  */
 
 import type { Comparator, DFSOrderPattern } from '../../types';
+import { HeapOptions } from "../../types";
 
 export class Heap<E = any> {
-  constructor(options: { comparator: Comparator<E>; elements?: E[] }) {
-    this._comparator = options.comparator;
-    if (options.elements && options.elements.length > 0) {
-      this._elements = options.elements;
-      this.fix();
+  options: HeapOptions<E>;
+
+  constructor(elements?: Iterable<E>, options?: HeapOptions<E>) {
+    const defaultComparator = (a: E, b: E) => {
+      if (!(typeof a === 'number' && typeof b === 'number')) {
+        throw new Error('The a, b params of compare function must be number');
+      } else {
+        return a - b;
+      }
+    }
+    if (options) {
+      this.options = options
+    } else {
+      this.options = {
+        comparator: defaultComparator
+      }
+    }
+
+    if (elements) {
+      for (const el of elements) {
+        this.push(el);
+      }
+      // this.fix();
     }
   }
 
@@ -22,12 +41,6 @@ export class Heap<E = any> {
     return this._elements;
   }
 
-  protected _comparator: Comparator<E>;
-
-  get comparator(): Comparator<E> {
-    return this._comparator;
-  }
-
   /**
    * Get the size (number of elements) of the heap.
    */
@@ -46,10 +59,11 @@ export class Heap<E = any> {
   /**
    * Static method that creates a binary heap from an array of elements and a comparison function.
    * @returns A new Heap instance.
+   * @param elements
    * @param options
    */
-  static heapify<E>(options: { elements: E[]; comparator: Comparator<E> }): Heap<E> {
-    return new Heap<E>(options);
+  static heapify<E>(elements: Iterable<E>, options: { comparator: Comparator<E> }): Heap<E> {
+    return new Heap<E>(elements, options);
   }
 
   /**
@@ -226,29 +240,30 @@ export class Heap<E = any> {
    * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
-  dfs(order: DFSOrderPattern): E[] {
+  dfs(order: DFSOrderPattern = 'pre'): E[] {
     const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
-    const dfsHelper = (index: number) => {
+    const _dfs = (index: number) => {
+      const left = 2 * index + 1, right = left + 1;
       if (index < this.size) {
         if (order === 'in') {
-          dfsHelper(2 * index + 1);
+          _dfs(left);
           result.push(this.elements[index]);
-          dfsHelper(2 * index + 2);
+          _dfs(right);
         } else if (order === 'pre') {
           result.push(this.elements[index]);
-          dfsHelper(2 * index + 1);
-          dfsHelper(2 * index + 2);
+          _dfs(left);
+          _dfs(right);
         } else if (order === 'post') {
-          dfsHelper(2 * index + 1);
-          dfsHelper(2 * index + 2);
+          _dfs(left);
+          _dfs(right);
           result.push(this.elements[index]);
         }
       }
     };
 
-    dfsHelper(0); // Traverse starting from the root node
+    _dfs(0); // Traverse starting from the root node
 
     return result;
   }
@@ -282,7 +297,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>({ comparator: this.comparator });
+    const clonedHeap = new Heap<E>([], this.options);
     clonedHeap._elements = [...this.elements];
     return clonedHeap;
   }
@@ -324,11 +339,70 @@ export class Heap<E = any> {
     for (let i = Math.floor(this.size / 2); i >= 0; i--) this._sinkDown(i, this.elements.length >> 1);
   }
 
+  * [Symbol.iterator]() {
+    for (const element of this.elements) {
+      yield element;
+    }
+  }
+
+  forEach(callback: (element: E, index: number, heap: this) => void): void {
+    let index = 0;
+    for (const el of this) {
+      callback(el, index, this);
+      index++;
+    }
+  }
+
+  filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E> {
+    const filteredHeap: Heap<E> = new Heap<E>([], this.options);
+    let index = 0;
+    for (const el of this) {
+      if (predicate(el, index, this)) {
+        filteredHeap.push(el);
+      }
+      index++;
+    }
+    return filteredHeap;
+  }
+
+  map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T> {
+
+    const mappedHeap: Heap<T> = new Heap<T>([], { comparator: comparator });
+    let index = 0;
+    for (const el of this) {
+      mappedHeap.add(callback(el, index, this));
+      index++;
+    }
+    return mappedHeap;
+  }
+
+  reduce<T>(
+    callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T,
+    initialValue: T
+  ): T {
+    let accumulator: T = initialValue;
+    let index = 0;
+    for (const el of this) {
+      accumulator = callback(accumulator, el, index, this);
+      index++;
+    }
+    return accumulator;
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
    */
 
+  print(): void {
+    console.log([...this]);
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -341,18 +415,13 @@ export class Heap<E = any> {
     while (index > 0) {
       const parent = (index - 1) >> 1;
       const parentItem = this.elements[parent];
-      if (this._comparator(parentItem, element) <= 0) break;
+      if (this.options.comparator(parentItem, element) <= 0) break;
       this.elements[index] = parentItem;
       index = parent;
     }
     this.elements[index] = element;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -369,12 +438,12 @@ export class Heap<E = any> {
       let minItem = this.elements[left];
       if (
         right < this.elements.length &&
-        this._comparator(minItem, this.elements[right]) > 0
+        this.options.comparator(minItem, this.elements[right]) > 0
       ) {
         left = right;
         minItem = this.elements[right];
       }
-      if (this._comparator(minItem, element) >= 0) break;
+      if (this.options.comparator(minItem, element) >= 0) break;
       this.elements[index] = minItem;
       index = left;
     }
@@ -401,7 +470,7 @@ export class FibonacciHeapNode<E> {
 export class FibonacciHeap<E> {
   constructor(comparator?: Comparator<E>) {
     this.clear();
-    this._comparator = comparator || this.defaultComparator;
+    this._comparator = comparator || this._defaultComparator;
 
     if (typeof this.comparator !== 'function') {
       throw new Error('FibonacciHeap constructor: given comparator should be a function.');
@@ -602,7 +671,7 @@ export class FibonacciHeap<E> {
       this._root = undefined;
     } else {
       this._min = z.right;
-      this.consolidate();
+      this._consolidate();
     }
 
     this._size--;
@@ -654,27 +723,27 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
+  /**
+   * Create a new node.
+   * @param element
+   * @protected
+   */
+  createNode(element: E): FibonacciHeapNode<E> {
+    return new FibonacciHeapNode<E>(element);
+  }
+
   /**
    * Default comparator function used by the heap.
    * @param {E} a
    * @param {E} b
    * @protected
    */
-  protected defaultComparator(a: E, b: E): number {
+  protected _defaultComparator(a: E, b: E): number {
     if (a < b) return -1;
     if (a > b) return 1;
     return 0;
   }
 
-  /**
-   * Create a new node.
-   * @param element
-   * @protected
-   */
-  protected createNode(element: E): FibonacciHeapNode<E> {
-    return new FibonacciHeapNode<E>(element);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -731,7 +800,7 @@ export class FibonacciHeap<E> {
    * @param x
    * @protected
    */
-  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
+  protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
     this.removeFromRoot(y);
     y.left = y;
     y.right = y;
@@ -752,7 +821,7 @@ export class FibonacciHeap<E> {
    * Remove and return the top element (smallest or largest element) from the heap.
    * @protected
    */
-  protected consolidate(): void {
+  protected _consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
     const elements = this.consumeLinkedList(this.root);
     let x: FibonacciHeapNode<E> | undefined,
@@ -773,7 +842,7 @@ export class FibonacciHeap<E> {
           y = t;
         }
 
-        this.link(y, x);
+        this._link(y, x);
         A[d] = undefined;
         d++;
       }

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

@@ -7,11 +7,12 @@
  */
 
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -19,8 +20,7 @@ export class MaxHeap<E = any> extends Heap<E> {
           return b - a;
         }
       }
-    }
-  ) {
-    super(options);
+    }) {
+    super(elements, options);
   }
 }

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

@@ -7,11 +7,12 @@
  */
 
 import { Heap } from './heap';
-import type { Comparator } from '../../types';
+import type { HeapOptions } from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    elements?: Iterable<E>,
+    options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');
@@ -19,8 +20,7 @@ export class MinHeap<E = any> extends Heap<E> {
           return a - b;
         }
       }
-    }
-  ) {
-    super(options);
+    }) {
+    super(elements, options);
   }
 }