heap-typed 1.38.0 → 1.38.1

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

@@ -21,21 +21,17 @@ export class HashTableNode<K, V> {
 import {HashFunction} from '../../types';
 
 export class HashTable<K, V> {
-  get hashFn(): HashFunction<K> {
-    return this._hashFn;
-  }
-
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
+  private static readonly DEFAULT_CAPACITY = 16;
+  private static readonly LOAD_FACTOR = 0.75;
 
-  get buckets(): Array<HashTableNode<K, V> | null> {
-    return this._buckets;
+  constructor(capacity: number = HashTable.DEFAULT_CAPACITY, hashFn?: HashFunction<K>) {
+    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);
   }
 
-  set buckets(value: Array<HashTableNode<K, V> | null>) {
-    this._buckets = value;
-  }
+  private _capacity: number;
 
   get capacity(): number {
     return this._capacity;
@@ -45,111 +41,30 @@ export class HashTable<K, V> {
     this._capacity = value;
   }
 
-  private static readonly DEFAULT_CAPACITY = 16;
-  private static readonly LOAD_FACTOR = 0.75;
-
-  private _capacity: number;
   private _size: number;
-  private _buckets: Array<HashTableNode<K, V> | null>;
-  private _hashFn: HashFunction<K>;
 
-  constructor(capacity: number = HashTable.DEFAULT_CAPACITY, hashFn?: HashFunction<K>) {
-    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);
+  get size(): number {
+    return this._size;
   }
 
-  /**
-   * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-   * capacity of the data structure.
-   * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-   * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-   * function is used to
-   * @returns the hash value of the key modulo the capacity of the data structure.
-   */
-  protected _defaultHashFn(key: K): number {
-    // Can be replaced with other hash functions as needed
-    const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
-    return hashValue % this._capacity;
-  }
+  private _buckets: Array<HashTableNode<K, V> | null>;
 
-  /**
-   * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-   * string hash function.
-   * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-   * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-   * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-   */
-  protected _multiplicativeStringHashFn<K>(key: K): number {
-    const keyString = String(key);
-    let hash = 0;
-    for (let i = 0; i < keyString.length; i++) {
-      const charCode = keyString.charCodeAt(i);
-      // Some constants for adjusting the hash function
-      const A = 0.618033988749895;
-      const M = 1 << 30; // 2^30
-      hash = (hash * A + charCode) % M;
-    }
-    return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+  get buckets(): Array<HashTableNode<K, V> | null> {
+    return this._buckets;
   }
 
-  /**
-   * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-   * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-   * type, but it will be converted to a string using the `String()` function before calculating the hash.
-   * @returns a number, which is the hash value calculated for the given key.
-   */
-  protected _murmurStringHashFn<K>(key: K): number {
-    const keyString = String(key);
-    const seed = 0;
-    let hash = seed;
-
-    for (let i = 0; i < keyString.length; i++) {
-      const char = keyString.charCodeAt(i);
-      hash = (hash ^ char) * 0x5bd1e995;
-      hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
-      hash = hash ^ (hash >>> 15);
-    }
-
-    return Math.abs(hash);
+  set buckets(value: Array<HashTableNode<K, V> | null>) {
+    this._buckets = value;
   }
 
-  /**
-   * The _hash function takes a key and returns a number.
-   * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-   * @returns The hash function is returning a number.
-   */
-  protected _hash(key: K): number {
-    return this.hashFn(key);
-  }
+  private _hashFn: HashFunction<K>;
 
-  /**
-   * The function calculates a hash value for a given string using the djb2 algorithm.
-   * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-   * which we want to calculate the hash value.
-   * @returns a number, which is the hash value of the input string.
-   */
-  protected _stringHash(key: string): number {
-    let hash = 0;
-    for (let i = 0; i < key.length; i++) {
-      hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
-    }
-    return hash;
+  get hashFn(): HashFunction<K> {
+    return this._hashFn;
   }
 
-  /**
-   * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-   * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-   * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-   * the key, which can be used for
-   * @returns a number, which is the hash value of the key.
-   */
-  protected _objectHash(key: K): number {
-    // If the key is an object, you can write a custom hash function
-    // For example, convert the object's properties to a string and use string hashing
-    // This is just an example; you should write a specific object hash function as needed
-    return this._stringHash(JSON.stringify(key));
+  set hashFn(value: HashFunction<K>) {
+    this._hashFn = value;
   }
 
   /**
@@ -240,6 +155,98 @@ export class HashTable<K, V> {
     }
   }
 
+  /**
+   * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
+   * capacity of the data structure.
+   * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
+   * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
+   * function is used to
+   * @returns the hash value of the key modulo the capacity of the data structure.
+   */
+  protected _defaultHashFn(key: K): number {
+    // Can be replaced with other hash functions as needed
+    const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
+    return hashValue % this._capacity;
+  }
+
+  /**
+   * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
+   * string hash function.
+   * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
+   * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
+   * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
+   */
+  protected _multiplicativeStringHashFn<K>(key: K): number {
+    const keyString = String(key);
+    let hash = 0;
+    for (let i = 0; i < keyString.length; i++) {
+      const charCode = keyString.charCodeAt(i);
+      // Some constants for adjusting the hash function
+      const A = 0.618033988749895;
+      const M = 1 << 30; // 2^30
+      hash = (hash * A + charCode) % M;
+    }
+    return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+  }
+
+  /**
+   * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
+   * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
+   * type, but it will be converted to a string using the `String()` function before calculating the hash.
+   * @returns a number, which is the hash value calculated for the given key.
+   */
+  protected _murmurStringHashFn<K>(key: K): number {
+    const keyString = String(key);
+    const seed = 0;
+    let hash = seed;
+
+    for (let i = 0; i < keyString.length; i++) {
+      const char = keyString.charCodeAt(i);
+      hash = (hash ^ char) * 0x5bd1e995;
+      hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
+      hash = hash ^ (hash >>> 15);
+    }
+
+    return Math.abs(hash);
+  }
+
+  /**
+   * The _hash function takes a key and returns a number.
+   * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
+   * @returns The hash function is returning a number.
+   */
+  protected _hash(key: K): number {
+    return this.hashFn(key);
+  }
+
+  /**
+   * The function calculates a hash value for a given string using the djb2 algorithm.
+   * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
+   * which we want to calculate the hash value.
+   * @returns a number, which is the hash value of the input string.
+   */
+  protected _stringHash(key: string): number {
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) {
+      hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
+    }
+    return hash;
+  }
+
+  /**
+   * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
+   * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
+   * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
+   * the key, which can be used for
+   * @returns a number, which is the hash value of the key.
+   */
+  protected _objectHash(key: K): number {
+    // If the key is an object, you can write a custom hash function
+    // For example, convert the object's properties to a string and use string hashing
+    // This is just an example; you should write a specific object hash function as needed
+    return this._stringHash(JSON.stringify(key));
+  }
+
   /**
    * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
    * capacity and rehashing all the existing key-value pairs into the new buckets.
@@ -270,8 +277,4 @@ export class HashTable<K, V> {
     this._buckets = newBuckets;
     this._capacity = newCapacity;
   }
-
-  get size(): number {
-    return this._size;
-  }
 }

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

@@ -15,6 +15,34 @@ export class Heap<E> {
     this.comparator = comparator;
   }
 
+  /**
+   * Get the size (number of elements) of the heap.
+   */
+  get size(): number {
+    return this.nodes.length;
+  }
+
+  /**
+   * Get the last element in the heap, which is not necessarily a leaf node.
+   * @returns The last element or undefined if the heap is empty.
+   */
+  get leaf(): E | undefined {
+    return this.nodes[this.size - 1] ?? undefined;
+  }
+
+  /**
+   * Static method that creates a binary heap from an array of nodes and a comparison function.
+   * @param nodes
+   * @param comparator - Comparison function.
+   * @returns A new Heap instance.
+   */
+  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
+    const binaryHeap = new Heap<E>(comparator);
+    binaryHeap.nodes = [...nodes];
+    binaryHeap.fix(); // Fix heap properties
+    return binaryHeap;
+  }
+
   /**
    * Insert an element into the heap and maintain the heap properties.
    * @param element - The element to be inserted.
@@ -59,57 +87,6 @@ export class Heap<E> {
     return this.poll();
   }
 
-  /**
-   * Float operation to maintain heap properties after adding an element.
-   * @param index - The index of the newly added element.
-   */
-  protected bubbleUp(index: number): void {
-    const element = this.nodes[index];
-    while (index > 0) {
-      const parentIndex = Math.floor((index - 1) / 2);
-      const parent = this.nodes[parentIndex];
-      if (this.comparator(element, parent) < 0) {
-        this.nodes[index] = parent;
-        this.nodes[parentIndex] = element;
-        index = parentIndex;
-      } else {
-        break;
-      }
-    }
-  }
-
-  /**
-   * Sinking operation to maintain heap properties after removing the top element.
-   * @param index - The index from which to start sinking.
-   */
-  protected sinkDown(index: number): void {
-    const leftChildIndex = 2 * index + 1;
-    const rightChildIndex = 2 * index + 2;
-    const length = this.nodes.length;
-    let targetIndex = index;
-
-    if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = leftChildIndex;
-    }
-    if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
-      targetIndex = rightChildIndex;
-    }
-
-    if (targetIndex !== index) {
-      const temp = this.nodes[index];
-      this.nodes[index] = this.nodes[targetIndex];
-      this.nodes[targetIndex] = temp;
-      this.sinkDown(targetIndex);
-    }
-  }
-
-  /**
-   * Fix the entire heap to maintain heap properties.
-   */
-  protected fix() {
-    for (let i = Math.floor(this.size / 2); i >= 0; i--) this.sinkDown(i);
-  }
-
   /**
    * Peek at the top element of the heap without removing it.
    * @returns The top element or undefined if the heap is empty.
@@ -121,21 +98,6 @@ export class Heap<E> {
     return this.nodes[0];
   }
 
-  /**
-   * Get the size (number of elements) of the heap.
-   */
-  get size(): number {
-    return this.nodes.length;
-  }
-
-  /**
-   * Get the last element in the heap, which is not necessarily a leaf node.
-   * @returns The last element or undefined if the heap is empty.
-   */
-  get leaf(): E | undefined {
-    return this.nodes[this.size - 1] ?? undefined;
-  }
-
   /**
    * Check if the heap is empty.
    * @returns True if the heap is empty, otherwise false.
@@ -238,16 +200,54 @@ export class Heap<E> {
   }
 
   /**
-   * Static method that creates a binary heap from an array of nodes and a comparison function.
-   * @param nodes
-   * @param comparator - Comparison function.
-   * @returns A new Heap instance.
+   * Float operation to maintain heap properties after adding an element.
+   * @param index - The index of the newly added element.
    */
-  static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E> {
-    const binaryHeap = new Heap<E>(comparator);
-    binaryHeap.nodes = [...nodes];
-    binaryHeap.fix(); // Fix heap properties
-    return binaryHeap;
+  protected bubbleUp(index: number): void {
+    const element = this.nodes[index];
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      const parent = this.nodes[parentIndex];
+      if (this.comparator(element, parent) < 0) {
+        this.nodes[index] = parent;
+        this.nodes[parentIndex] = element;
+        index = parentIndex;
+      } else {
+        break;
+      }
+    }
+  }
+
+  /**
+   * Sinking operation to maintain heap properties after removing the top element.
+   * @param index - The index from which to start sinking.
+   */
+  protected sinkDown(index: number): void {
+    const leftChildIndex = 2 * index + 1;
+    const rightChildIndex = 2 * index + 2;
+    const length = this.nodes.length;
+    let targetIndex = index;
+
+    if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
+      targetIndex = leftChildIndex;
+    }
+    if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
+      targetIndex = rightChildIndex;
+    }
+
+    if (targetIndex !== index) {
+      const temp = this.nodes[index];
+      this.nodes[index] = this.nodes[targetIndex];
+      this.nodes[targetIndex] = temp;
+      this.sinkDown(targetIndex);
+    }
+  }
+
+  /**
+   * Fix the entire heap to maintain heap properties.
+   */
+  protected fix() {
+    for (let i = Math.floor(this.size / 2); i >= 0; i--) this.sinkDown(i);
   }
 }
 
@@ -259,6 +259,7 @@ export class FibonacciHeapNode<E> {
   child?: FibonacciHeapNode<E>;
   parent?: FibonacciHeapNode<E>;
   marked: boolean;
+
   constructor(element: E, degree = 0) {
     this.element = element;
     this.degree = degree;
@@ -268,8 +269,8 @@ export class FibonacciHeapNode<E> {
 
 export class FibonacciHeap<E> {
   root?: FibonacciHeapNode<E>;
-  protected min?: FibonacciHeapNode<E>;
   size: number = 0;
+  protected min?: FibonacciHeapNode<E>;
   protected readonly comparator: Comparator<E>;
 
   constructor(comparator?: Comparator<E>) {
@@ -281,18 +282,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * Default comparator function used by the heap.
-   * @param {E} a
-   * @param {E} b
-   * @protected
-   */
-  protected defaultComparator(a: E, b: E): number {
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  }
-
   /**
    * Get the size (number of elements) of the heap.
    * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
@@ -303,30 +292,6 @@ export class FibonacciHeap<E> {
     this.size = 0;
   }
 
-  /**
-   * Create a new node.
-   * @param element
-   * @protected
-   */
-  protected createNode(element: E): FibonacciHeapNode<E> {
-    return new FibonacciHeapNode<E>(element);
-  }
-
-  /**
-   * Merge the given node with the root list.
-   * @param node - The node to be merged.
-   */
-  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
-    if (!this.root) {
-      this.root = node;
-    } else {
-      node.right = this.root.right;
-      node.left = this.root;
-      this.root.right!.left = node;
-      this.root.right = node;
-    }
-  }
-
   /**
    * O(1) time operation.
    * Insert an element into the heap and maintain the heap properties.
@@ -394,18 +359,6 @@ export class FibonacciHeap<E> {
     return nodes;
   }
 
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @param node - The node to be removed.
-   * @protected
-   */
-  protected removeFromRoot(node: FibonacciHeapNode<E>): void {
-    if (this.root === node) this.root = node.right;
-    if (node.left) node.left.right = node.right;
-    if (node.right) node.right.left = node.left;
-  }
-
   /**
    * O(log n) time operation.
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -423,63 +376,6 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @param y
-   * @param x
-   * @protected
-   */
-  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
-    this.removeFromRoot(y);
-    y.left = y;
-    y.right = y;
-    this.mergeWithChild(x, y);
-    x.degree++;
-    y.parent = x;
-  }
-
-  /**
-   * O(log n) time operation.
-   * Remove and return the top element (smallest or largest element) from the heap.
-   * @protected
-   */
-  protected consolidate(): void {
-    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
-    const nodes = this.consumeLinkedList(this.root);
-    let x: FibonacciHeapNode<E> | undefined,
-      y: FibonacciHeapNode<E> | undefined,
-      d: number,
-      t: FibonacciHeapNode<E> | undefined;
-
-    for (const node of nodes) {
-      x = node;
-      d = x.degree;
-
-      while (A[d]) {
-        y = A[d] as FibonacciHeapNode<E>;
-
-        if (this.comparator(x.element, y.element) > 0) {
-          t = x;
-          x = y;
-          y = t;
-        }
-
-        this.link(y, x);
-        A[d] = undefined;
-        d++;
-      }
-
-      A[d] = x;
-    }
-
-    for (let i = 0; i < this.size; i++) {
-      if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
-        this.min = A[i]!;
-      }
-    }
-  }
-
   /**
    * O(log n) time operation.
    * Remove and return the top element (smallest or largest element) from the heap.
@@ -557,4 +453,109 @@ export class FibonacciHeap<E> {
     // Clear the heap that was merged
     heapToMerge.clear();
   }
+
+  /**
+   * Default comparator function used by the heap.
+   * @param {E} a
+   * @param {E} b
+   * @protected
+   */
+  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);
+  }
+
+  /**
+   * Merge the given node with the root list.
+   * @param node - The node to be merged.
+   */
+  protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
+    if (!this.root) {
+      this.root = node;
+    } else {
+      node.right = this.root.right;
+      node.left = this.root;
+      this.root.right!.left = node;
+      this.root.right = node;
+    }
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @param node - The node to be removed.
+   * @protected
+   */
+  protected removeFromRoot(node: FibonacciHeapNode<E>): void {
+    if (this.root === node) this.root = node.right;
+    if (node.left) node.left.right = node.right;
+    if (node.right) node.right.left = node.left;
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @param y
+   * @param x
+   * @protected
+   */
+  protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
+    this.removeFromRoot(y);
+    y.left = y;
+    y.right = y;
+    this.mergeWithChild(x, y);
+    x.degree++;
+    y.parent = x;
+  }
+
+  /**
+   * O(log n) time operation.
+   * Remove and return the top element (smallest or largest element) from the heap.
+   * @protected
+   */
+  protected consolidate(): void {
+    const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
+    const nodes = this.consumeLinkedList(this.root);
+    let x: FibonacciHeapNode<E> | undefined,
+      y: FibonacciHeapNode<E> | undefined,
+      d: number,
+      t: FibonacciHeapNode<E> | undefined;
+
+    for (const node of nodes) {
+      x = node;
+      d = x.degree;
+
+      while (A[d]) {
+        y = A[d] as FibonacciHeapNode<E>;
+
+        if (this.comparator(x.element, y.element) > 0) {
+          t = x;
+          x = y;
+          y = t;
+        }
+
+        this.link(y, x);
+        A[d] = undefined;
+        d++;
+      }
+
+      A[d] = x;
+    }
+
+    for (let i = 0; i < this.size; i++) {
+      if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
+        this.min = A[i]!;
+      }
+    }
+  }
 }