data-structure-typed 1.33.6 → 1.33.8

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

@@ -87,12 +87,21 @@ export class SegmentTree {
    * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
    */
   constructor(values: number[], start?: number, end?: number) {
+    console.log('values.length:', values.length);
     start = start || 0;
     end = end || values.length - 1;
     this._values = values;
     this._start = start;
     this._end = end;
-    this._root = this.build(start, end);
+
+    if (values.length > 0) {
+      console.log('Initializing with non-empty array');
+      this._root = this.build(start, end);
+    } else {
+      console.log('Initializing with empty array');
+      this._root = null;
+      this._values = [];
+    }
   }
 
   private _values: number[] = [];
@@ -119,15 +128,18 @@ export class SegmentTree {
   }
 
   /**
-   * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
-   * for each segment.
+   * The build function creates a segment tree by recursively dividing the given range into smaller segments and assigning
+   * the sum of values to each segment.
    * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
    * building the segment tree.
-   * @param {number} end - The `end` parameter represents the ending index of the segment or range for which we are
-   * building the segment tree.
+   * @param {number} end - The "end" parameter represents the ending index of the segment or range for which we want to
+   * build a segment tree.
    * @returns a SegmentTreeNode object.
    */
   build(start: number, end: number): SegmentTreeNode {
+    if (start > end) {
+      return new SegmentTreeNode(start, end, 0);
+    }
     if (start === end) return new SegmentTreeNode(start, end, this._values[start]);
 
     const mid = start + Math.floor((end - start) / 2);
@@ -192,33 +204,39 @@ export class SegmentTree {
       return 0;
     }
 
+    if (indexA < 0 || indexB >= this.values.length || indexA > indexB) {
+      return NaN;
+    }
+
     const dfs = (cur: SegmentTreeNode, i: number, j: number): number => {
-      if (cur.start === i && cur.end === j) {
+      if (i <= cur.start && j >= cur.end) {
+        // The range [i, j] completely covers the current node's range [cur.start, cur.end]
         return cur.sum;
       }
       const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
       if (j <= mid) {
-        // TODO after no-non-null-assertion not ensure the logic
         if (cur.left) {
           return dfs(cur.left, i, j);
         } else {
           return NaN;
         }
       } else if (i > mid) {
-        // TODO after no-non-null-assertion not ensure the logic
         if (cur.right) {
-          // TODO after no-non-null-assertion not ensure the logic
           return dfs(cur.right, i, j);
         } else {
           return NaN;
         }
       } else {
-        // TODO after no-non-null-assertion not ensure the logic
-        if (cur.left && cur.right) {
-          return dfs(cur.left, i, mid) + dfs(cur.right, mid + 1, j);
-        } else {
-          return NaN;
+        // Query both left and right subtrees
+        let leftSum = 0;
+        let rightSum = 0;
+        if (cur.left) {
+          leftSum = dfs(cur.left, i, mid);
+        }
+        if (cur.right) {
+          rightSum = dfs(cur.right, mid + 1, j);
         }
+        return leftSum + rightSum;
       }
     };
     return dfs(root, indexA, indexB);

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

@@ -0,0 +1,203 @@
+import {HashFunction} from '../../types';
+
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class HashMap<K, V> {
+  get hashFn(): HashFunction<K> {
+    return this._hashFn;
+  }
+
+  set hashFn(value: HashFunction<K>) {
+    this._hashFn = value;
+  }
+  get table(): Array<Array<[K, V]>> {
+    return this._table;
+  }
+
+  set table(value: Array<Array<[K, V]>>) {
+    this._table = value;
+  }
+
+  get capacityMultiplier(): number {
+    return this._capacityMultiplier;
+  }
+
+  set capacityMultiplier(value: number) {
+    this._capacityMultiplier = value;
+  }
+
+  get loadFactor(): number {
+    return this._loadFactor;
+  }
+
+  set loadFactor(value: number) {
+    this._loadFactor = value;
+  }
+
+  get initialCapacity(): number {
+    return this._initialCapacity;
+  }
+
+  set initialCapacity(value: number) {
+    this._initialCapacity = value;
+  }
+
+  get size(): number {
+    return this._size;
+  }
+
+  set size(value: number) {
+    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;
+      });
+  }
+
+  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
+  }
+
+  set(key: K, value: V): void {
+    const loadFactor = this.size / this.table.length;
+    if (loadFactor >= this.loadFactor) {
+      this.resizeTable(this.table.length * this.capacityMultiplier);
+    }
+
+    const index = this._hash(key);
+    if (!this.table[index]) {
+      this.table[index] = [];
+    }
+
+    // Check if the key already exists in the bucket
+    for (let i = 0; i < this.table[index].length; i++) {
+      if (this.table[index][i][0] === key) {
+        this.table[index][i][1] = value;
+        return;
+      }
+    }
+
+    this.table[index].push([key, value]);
+    this.size++;
+  }
+
+  get(key: K): V | undefined {
+    const index = this._hash(key);
+    if (!this.table[index]) {
+      return undefined;
+    }
+
+    for (const [k, v] of this.table[index]) {
+      if (k === key) {
+        return v;
+      }
+    }
+
+    return undefined;
+  }
+
+  remove(key: K): void {
+    const index = this._hash(key);
+    if (!this.table[index]) {
+      return;
+    }
+
+    for (let i = 0; i < this.table[index].length; i++) {
+      if (this.table[index][i][0] === key) {
+        this.table[index].splice(i, 1);
+        this.size--;
+
+        // Check if the table needs to be resized down
+        const loadFactor = this.size / this.table.length;
+        if (loadFactor < this.loadFactor / this.capacityMultiplier) {
+          this.resizeTable(this.table.length / this.capacityMultiplier);
+        }
+        return;
+      }
+    }
+  }
+
+  *entries(): IterableIterator<[K, V]> {
+    for (const bucket of this.table) {
+      if (bucket) {
+        for (const [key, value] of bucket) {
+          yield [key, value];
+        }
+      }
+    }
+  }
+
+  [Symbol.iterator](): IterableIterator<[K, V]> {
+    return this.entries();
+  }
+
+  clear(): void {
+    this.size = 0;
+    this.table = new Array(this.initialCapacity);
+  }
+
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+}

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

@@ -5,10 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class HashNode<K, V> {
+
+export class HashTableNode<K, V> {
   key: K;
   val: V;
-  next: HashNode<K, V> | null;
+  next: HashTableNode<K, V> | null;
 
   constructor(key: K, val: V) {
     this.key = key;
@@ -17,21 +18,23 @@ export class HashNode<K, V> {
   }
 }
 
+import {HashFunction} from '../../types';
+
 export class HashTable<K, V> {
-  get buckets(): Array<HashNode<K, V> | null> {
-    return this._buckets;
+  get hashFn(): HashFunction<K> {
+    return this._hashFn;
   }
 
-  set buckets(value: Array<HashNode<K, V> | null>) {
-    this._buckets = value;
+  set hashFn(value: HashFunction<K>) {
+    this._hashFn = value;
   }
 
-  get size(): number {
-    return this._size;
+  get buckets(): Array<HashTableNode<K, V> | null> {
+    return this._buckets;
   }
 
-  set size(value: number) {
-    this._size = value;
+  set buckets(value: Array<HashTableNode<K, V> | null>) {
+    this._buckets = value;
   }
 
   get capacity(): number {
@@ -42,82 +45,163 @@ 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<HashNode<K, V> | null>;
+  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);
+  }
 
   /**
-   * The constructor initializes the capacity, size, and buckets of an object.
-   * @param [capacity=1000] - The `capacity` parameter represents the maximum number of elements that the data structure
-   * can hold. It is an optional parameter with a default value of 1000.
+   * 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.
    */
-  constructor(capacity = 1000) {
-    this._capacity = capacity;
-    this._size = 0;
-    this._buckets = new Array(this.capacity).fill(null);
+  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 hash function takes a key, converts it to a string, calculates the sum of the ASCII values of its characters, and
-   * returns the remainder when divided by the capacity of the data structure.
-   * @param {K} key - The `key` parameter represents the key that needs to be hashed. It is of type `K`, which means it can
-   * be any data type that can be converted to a string.
-   * @returns The hash value of the key modulo the capacity of the data structure.
+   * 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.
    */
-  private hash(key: K): number {
+  protected _multiplicativeStringHashFn<K>(key: K): number {
     const keyString = String(key);
     let hash = 0;
     for (let i = 0; i < keyString.length; i++) {
-      hash += keyString.charCodeAt(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 % this.capacity;
+    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 put function adds a key-value pair to a hash table, handling collisions by chaining.
+   * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
    * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-   * table. It is of type K, which can be any data type that can be used as a key, such as a string, number, or object.
-   * @param {V} val - The `val` parameter represents the value associated with the key in the hash table.
-   * @returns Nothing is being returned. The return type of the function is void, which means it does not return any value.
+   * table. It is of type K, which is a generic type representing the key's data type.
+   * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+   * table.
+   * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+   * value.
    */
-  put(key: K, val: V): void {
-    const index = this.hash(key);
-    const newNode = new HashNode(key, val);
+  set(key: K, val: V): void {
+    const index = this._hash(key);
+    const newNode = new HashTableNode<K, V>(key, val);
 
-    if (!this.buckets[index]) {
-      this.buckets[index] = newNode;
+    if (!this._buckets[index]) {
+      this._buckets[index] = newNode;
     } else {
-      // Handle collision by chaining
-      let currentNode = this.buckets[index]!;
-      while (currentNode.next) {
+      // Handle collisions, consider using open addressing, etc.
+      let currentNode = this._buckets[index]!;
+      while (currentNode) {
         if (currentNode.key === key) {
-          // Update the val if the key already exists
+          // If the key already exists, update the value
           currentNode.val = val;
           return;
         }
+        if (!currentNode.next) {
+          break;
+        }
         currentNode = currentNode.next;
       }
-      if (currentNode.key === key) {
-        // Update the val if the key already exists (last node)
-        currentNode.val = val;
-      } else {
-        // Add the new node to the end of the chain
-        currentNode.next = newNode;
-      }
+      // Add to the end of the linked list
+      currentNode.next = newNode;
+    }
+    this._size++;
+
+    // If the load factor is too high, resize the hash table
+    if (this._size / this._capacity >= HashTable.LOAD_FACTOR) {
+      this._expand();
     }
-    this.size++;
   }
 
   /**
    * The `get` function retrieves the value associated with a given key from a hash table.
-   * @param {K} key - The parameter "key" represents the key of the element that we want to retrieve from the data
+   * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
    * structure.
    * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
    * not found, it returns `undefined`.
    */
   get(key: K): V | undefined {
-    const index = this.hash(key);
-    let currentNode = this.buckets[index];
+    const index = this._hash(key);
+    let currentNode = this._buckets[index];
 
     while (currentNode) {
       if (currentNode.key === key) {
@@ -129,29 +213,65 @@ export class HashTable<K, V> {
   }
 
   /**
-   * The `remove` function removes a key-value pair from a hash table.
+   * The remove function removes a key-value pair from a hash table.
    * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
    * table.
    * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
    * any value.
    */
   remove(key: K): void {
-    const index = this.hash(key);
-    let currentNode = this.buckets[index];
-    let prevNode: HashNode<K, V> | null = null;
+    const index = this._hash(key);
+    let currentNode = this._buckets[index];
+    let prevNode: HashTableNode<K, V> | null = null;
 
     while (currentNode) {
       if (currentNode.key === key) {
         if (prevNode) {
           prevNode.next = currentNode.next;
         } else {
-          this.buckets[index] = currentNode.next;
+          this._buckets[index] = currentNode.next;
         }
-        this.size--;
+        this._size--;
+        currentNode.next = null; // Release memory
         return;
       }
       prevNode = currentNode;
       currentNode = currentNode.next;
     }
   }
+
+  /**
+   * 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.
+   */
+  protected _expand(): void {
+    const newCapacity = this._capacity * 2;
+    const newBuckets = new Array<HashTableNode<K, V> | null>(newCapacity).fill(null);
+
+    for (const bucket of this._buckets) {
+      let currentNode = bucket;
+      while (currentNode) {
+        const newIndex = this._hash(currentNode.key);
+        const newNode = new HashTableNode<K, V>(currentNode.key, currentNode.val);
+
+        if (!newBuckets[newIndex]) {
+          newBuckets[newIndex] = newNode;
+        } else {
+          let currentNewNode = newBuckets[newIndex]!;
+          while (currentNewNode.next) {
+            currentNewNode = currentNewNode.next;
+          }
+          currentNewNode.next = newNode;
+        }
+        currentNode = currentNode.next;
+      }
+    }
+
+    this._buckets = newBuckets;
+    this._capacity = newCapacity;
+  }
+
+  get size(): number {
+    return this._size;
+  }
 }

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

@@ -4,3 +4,4 @@ export * from './coordinate-set';
 export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
+export * from './hash-map';