heap-typed 1.38.0 → 1.38.2

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

@@ -8,28 +8,47 @@ import {HashFunction} from '../../types';
  * @license MIT License
  */
 export class HashMap<K, V> {
-  get hashFn(): HashFunction<K> {
-    return this._hashFn;
+  /**
+   * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
+   * multiplier, size, table array, and hash function.
+   * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
+   * buckets or slots available for storing key-value pairs. The default value is 16.
+   * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
+   * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
+   * load factor is reached, the hash table will
+   * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
+   * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
+   * default hash function converts the key to a string, calculates the sum of the
+   */
+  constructor(initialCapacity = 16, loadFactor = 0.75, hashFn?: HashFunction<K>) {
+    this._initialCapacity = initialCapacity;
+    this._loadFactor = loadFactor;
+    this._capacityMultiplier = 2;
+    this._size = 0;
+    this._table = new Array(initialCapacity);
+    this._hashFn =
+      hashFn ||
+      ((key: K) => {
+        const strKey = String(key);
+        let hash = 0;
+        for (let i = 0; i < strKey.length; i++) {
+          hash += strKey.charCodeAt(i);
+        }
+        return hash % this.table.length;
+      });
   }
 
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
-  get table(): Array<Array<[K, V]>> {
-    return this._table;
-  }
+  private _initialCapacity: number;
 
-  set table(value: Array<Array<[K, V]>>) {
-    this._table = value;
+  get initialCapacity(): number {
+    return this._initialCapacity;
   }
 
-  get capacityMultiplier(): number {
-    return this._capacityMultiplier;
+  set initialCapacity(value: number) {
+    this._initialCapacity = value;
   }
 
-  set capacityMultiplier(value: number) {
-    this._capacityMultiplier = value;
-  }
+  private _loadFactor: number;
 
   get loadFactor(): number {
     return this._loadFactor;
@@ -39,14 +58,18 @@ export class HashMap<K, V> {
     this._loadFactor = value;
   }
 
-  get initialCapacity(): number {
-    return this._initialCapacity;
+  private _capacityMultiplier: number;
+
+  get capacityMultiplier(): number {
+    return this._capacityMultiplier;
   }
 
-  set initialCapacity(value: number) {
-    this._initialCapacity = value;
+  set capacityMultiplier(value: number) {
+    this._capacityMultiplier = value;
   }
 
+  private _size: number;
+
   get size(): number {
     return this._size;
   }
@@ -55,68 +78,24 @@ export class HashMap<K, V> {
     this._size = value;
   }
 
-  private _initialCapacity: number;
-  private _loadFactor: number;
-  private _capacityMultiplier: number;
-  private _size: number;
   private _table: Array<Array<[K, V]>>;
-  private _hashFn: HashFunction<K>;
 
-  /**
-   * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
-   * multiplier, size, table array, and hash function.
-   * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
-   * buckets or slots available for storing key-value pairs. The default value is 16.
-   * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
-   * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
-   * load factor is reached, the hash table will
-   * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
-   * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
-   * default hash function converts the key to a string, calculates the sum of the
-   */
-  constructor(initialCapacity = 16, loadFactor = 0.75, hashFn?: HashFunction<K>) {
-    this._initialCapacity = initialCapacity;
-    this._loadFactor = loadFactor;
-    this._capacityMultiplier = 2;
-    this._size = 0;
-    this._table = new Array(initialCapacity);
-    this._hashFn =
-      hashFn ||
-      ((key: K) => {
-        const strKey = String(key);
-        let hash = 0;
-        for (let i = 0; i < strKey.length; i++) {
-          hash += strKey.charCodeAt(i);
-        }
-        return hash % this.table.length;
-      });
+  get table(): Array<Array<[K, V]>> {
+    return this._table;
   }
 
-  private _hash(key: K): number {
-    return this._hashFn(key);
+  set table(value: Array<Array<[K, V]>>) {
+    this._table = value;
   }
 
-  /**
-   * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-   * rehashing the key-value pairs from the old table into the new table.
-   * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-   * the number of buckets that the new table should have.
-   */
-  private resizeTable(newCapacity: number): void {
-    const newTable = new Array(newCapacity);
-    for (const bucket of this._table) {
-      // Note that this is this._table
-      if (bucket) {
-        for (const [key, value] of bucket) {
-          const newIndex = this._hash(key) % newCapacity;
-          if (!newTable[newIndex]) {
-            newTable[newIndex] = [];
-          }
-          newTable[newIndex].push([key, value]);
-        }
-      }
-    }
-    this._table = newTable; // Again, here is this._table
+  private _hashFn: HashFunction<K>;
+
+  get hashFn(): HashFunction<K> {
+    return this._hashFn;
+  }
+
+  set hashFn(value: HashFunction<K>) {
+    this._hashFn = value;
   }
 
   set(key: K, value: V): void {
@@ -178,7 +157,7 @@ export class HashMap<K, V> {
     }
   }
 
-  *entries(): IterableIterator<[K, V]> {
+  * entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {
@@ -200,4 +179,31 @@ export class HashMap<K, V> {
   isEmpty(): boolean {
     return this.size === 0;
   }
+
+  private _hash(key: K): number {
+    return this._hashFn(key);
+  }
+
+  /**
+   * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+   * rehashing the key-value pairs from the old table into the new table.
+   * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+   * the number of buckets that the new table should have.
+   */
+  private resizeTable(newCapacity: number): void {
+    const newTable = new Array(newCapacity);
+    for (const bucket of this._table) {
+      // Note that this is this._table
+      if (bucket) {
+        for (const [key, value] of bucket) {
+          const newIndex = this._hash(key) % newCapacity;
+          if (!newTable[newIndex]) {
+            newTable[newIndex] = [];
+          }
+          newTable[newIndex].push([key, value]);
+        }
+      }
+    }
+    this._table = newTable; // Again, here is this._table
+  }
 }

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/hash/tree-map.ts

@@ -1 +1,2 @@
-export class TreeMap {}
+export class TreeMap {
+}

package/src/data-structures/hash/tree-set.ts

@@ -1 +1,2 @@
-export class TreeSet {}
+export class TreeSet {
+}