data-structure-typed 1.33.6 → 1.33.8

package/docs/modules.html

@@ -49,8 +49,9 @@
 <a href="classes/DirectedVertex.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Directed<wbr/>Vertex</span></a>
 <a href="classes/DoublyLinkedList.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List</span></a>
 <a href="classes/DoublyLinkedListNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List<wbr/>Node</span></a>
-<a href="classes/HashNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Node</span></a>
+<a href="classes/HashMap.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Map</span></a>
 <a href="classes/HashTable.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table</span></a>
+<a href="classes/HashTableNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table<wbr/>Node</span></a>
 <a href="classes/Heap.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap</span></a>
 <a href="classes/HeapItem.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap<wbr/>Item</span></a>
 <a href="classes/LinkedListQueue.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Linked<wbr/>List<wbr/>Queue</span></a>
@@ -74,7 +75,8 @@
 <a href="classes/SegmentTreeNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Segment<wbr/>Tree<wbr/>Node</span></a>
 <a href="classes/SinglyLinkedList.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Singly<wbr/>Linked<wbr/>List</span></a>
 <a href="classes/SinglyLinkedListNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Singly<wbr/>Linked<wbr/>List<wbr/>Node</span></a>
-<a href="classes/SkipLinkedList.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>Linked<wbr/>List</span></a>
+<a href="classes/SkipList.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>List</span></a>
+<a href="classes/SkipListNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>List<wbr/>Node</span></a>
 <a href="classes/SplayTree.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Splay<wbr/>Tree</span></a>
 <a href="classes/Stack.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Stack</span></a>
 <a href="classes/TreeMap.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Tree<wbr/>Map</span></a>
@@ -122,6 +124,7 @@
 <a href="types/Direction.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Direction</span></a>
 <a href="types/DummyAny.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Dummy<wbr/>Any</span></a>
 <a href="types/EdgeId.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Edge<wbr/>Id</span></a>
+<a href="types/HashFunction.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Hash<wbr/>Function</span></a>
 <a href="types/HeapOptions.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Heap<wbr/>Options</span></a>
 <a href="types/IAVLTreeNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>IAVLTree<wbr/>Node</span></a>
 <a href="types/IBSTNode.html" class="tsd-index-link"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>IBSTNode</span></a>
@@ -217,8 +220,9 @@
 <li><a href="classes/DirectedVertex.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Directed<wbr/>Vertex</span></a></li>
 <li><a href="classes/DoublyLinkedList.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List</span></a></li>
 <li><a href="classes/DoublyLinkedListNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Doubly<wbr/>Linked<wbr/>List<wbr/>Node</span></a></li>
-<li><a href="classes/HashNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Node</span></a></li>
+<li><a href="classes/HashMap.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Map</span></a></li>
 <li><a href="classes/HashTable.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table</span></a></li>
+<li><a href="classes/HashTableNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Hash<wbr/>Table<wbr/>Node</span></a></li>
 <li><a href="classes/Heap.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap</span></a></li>
 <li><a href="classes/HeapItem.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Heap<wbr/>Item</span></a></li>
 <li><a href="classes/LinkedListQueue.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Linked<wbr/>List<wbr/>Queue</span></a></li>
@@ -242,7 +246,8 @@
 <li><a href="classes/SegmentTreeNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Segment<wbr/>Tree<wbr/>Node</span></a></li>
 <li><a href="classes/SinglyLinkedList.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Singly<wbr/>Linked<wbr/>List</span></a></li>
 <li><a href="classes/SinglyLinkedListNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Singly<wbr/>Linked<wbr/>List<wbr/>Node</span></a></li>
-<li><a href="classes/SkipLinkedList.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>Linked<wbr/>List</span></a></li>
+<li><a href="classes/SkipList.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>List</span></a></li>
+<li><a href="classes/SkipListNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Skip<wbr/>List<wbr/>Node</span></a></li>
 <li><a href="classes/SplayTree.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Splay<wbr/>Tree</span></a></li>
 <li><a href="classes/Stack.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Stack</span></a></li>
 <li><a href="classes/TreeMap.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-128"></use></svg><span>Tree<wbr/>Map</span></a></li>
@@ -284,6 +289,7 @@
 <li><a href="types/Direction.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Direction</span></a></li>
 <li><a href="types/DummyAny.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Dummy<wbr/>Any</span></a></li>
 <li><a href="types/EdgeId.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Edge<wbr/>Id</span></a></li>
+<li><a href="types/HashFunction.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Hash<wbr/>Function</span></a></li>
 <li><a href="types/HeapOptions.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>Heap<wbr/>Options</span></a></li>
 <li><a href="types/IAVLTreeNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>IAVLTree<wbr/>Node</span></a></li>
 <li><a href="types/IBSTNode.html"><svg class="tsd-kind-icon" viewBox="0 0 24 24"><use href="#icon-4194304"></use></svg><span>IBSTNode</span></a></li>

package/lib/data-structures/binary-tree/segment-tree.d.ts

@@ -47,12 +47,12 @@ export declare class SegmentTree {
     private _root;
     get root(): SegmentTreeNode | null;
     /**
-     * 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;

package/lib/data-structures/binary-tree/segment-tree.js

@@ -68,12 +68,21 @@ export class SegmentTree {
     constructor(values, start, end) {
         this._values = [];
         this._start = 0;
+        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 = [];
+        }
     }
     get values() {
         return this._values;
@@ -88,15 +97,18 @@ export class SegmentTree {
         return this._root;
     }
     /**
-     * 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, end) {
+        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);
@@ -159,13 +171,16 @@ export class SegmentTree {
         if (!root) {
             return 0;
         }
+        if (indexA < 0 || indexB >= this.values.length || indexA > indexB) {
+            return NaN;
+        }
         const dfs = (cur, i, j) => {
-            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);
                 }
@@ -174,9 +189,7 @@ export class SegmentTree {
                 }
             }
             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 {
@@ -184,13 +197,16 @@ export class SegmentTree {
                 }
             }
             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);
+                // Query both left and right subtrees
+                let leftSum = 0;
+                let rightSum = 0;
+                if (cur.left) {
+                    leftSum = dfs(cur.left, i, mid);
                 }
-                else {
-                    return NaN;
+                if (cur.right) {
+                    rightSum = dfs(cur.right, mid + 1, j);
                 }
+                return leftSum + rightSum;
             }
         };
         return dfs(root, indexA, indexB);

package/lib/data-structures/hash/hash-map.d.ts

@@ -0,0 +1,56 @@
+import { HashFunction } from '../../types';
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class HashMap<K, V> {
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    get table(): Array<Array<[K, V]>>;
+    set table(value: Array<Array<[K, V]>>);
+    get capacityMultiplier(): number;
+    set capacityMultiplier(value: number);
+    get loadFactor(): number;
+    set loadFactor(value: number);
+    get initialCapacity(): number;
+    set initialCapacity(value: number);
+    get size(): number;
+    set size(value: number);
+    private _initialCapacity;
+    private _loadFactor;
+    private _capacityMultiplier;
+    private _size;
+    private _table;
+    private _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?: number, loadFactor?: number, hashFn?: HashFunction<K>);
+    private _hash;
+    /**
+     * 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;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    remove(key: K): void;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    clear(): void;
+    isEmpty(): boolean;
+}

package/lib/data-structures/hash/hash-map.js

@@ -0,0 +1,167 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class HashMap {
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
+    }
+    get table() {
+        return this._table;
+    }
+    set table(value) {
+        this._table = value;
+    }
+    get capacityMultiplier() {
+        return this._capacityMultiplier;
+    }
+    set capacityMultiplier(value) {
+        this._capacityMultiplier = value;
+    }
+    get loadFactor() {
+        return this._loadFactor;
+    }
+    set loadFactor(value) {
+        this._loadFactor = value;
+    }
+    get initialCapacity() {
+        return this._initialCapacity;
+    }
+    set initialCapacity(value) {
+        this._initialCapacity = value;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    /**
+     * 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) {
+        this._initialCapacity = initialCapacity;
+        this._loadFactor = loadFactor;
+        this._capacityMultiplier = 2;
+        this._size = 0;
+        this._table = new Array(initialCapacity);
+        this._hashFn =
+            hashFn ||
+                ((key) => {
+                    const strKey = String(key);
+                    let hash = 0;
+                    for (let i = 0; i < strKey.length; i++) {
+                        hash += strKey.charCodeAt(i);
+                    }
+                    return hash % this.table.length;
+                });
+    }
+    _hash(key) {
+        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.
+     */
+    resizeTable(newCapacity) {
+        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, value) {
+        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) {
+        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) {
+        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() {
+        for (const bucket of this.table) {
+            if (bucket) {
+                for (const [key, value] of bucket) {
+                    yield [key, value];
+                }
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    clear() {
+        this.size = 0;
+        this.table = new Array(this.initialCapacity);
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+}

package/lib/data-structures/hash/hash-table.d.ts

@@ -5,58 +5,102 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class HashNode<K, V> {
+export declare class HashTableNode<K, V> {
     key: K;
     val: V;
-    next: HashNode<K, V> | null;
+    next: HashTableNode<K, V> | null;
     constructor(key: K, val: V);
 }
+import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    get buckets(): Array<HashNode<K, V> | null>;
-    set buckets(value: Array<HashNode<K, V> | null>);
-    get size(): number;
-    set size(value: number);
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    get buckets(): Array<HashTableNode<K, V> | null>;
+    set buckets(value: Array<HashTableNode<K, V> | null>);
     get capacity(): number;
     set capacity(value: number);
+    private static readonly DEFAULT_CAPACITY;
+    private static readonly LOAD_FACTOR;
     private _capacity;
     private _size;
     private _buckets;
+    private _hashFn;
+    constructor(capacity?: number, hashFn?: HashFunction<K>);
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
     /**
-     * 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 _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.
      */
-    constructor(capacity?: number);
+    protected _hash(key: K): number;
     /**
-     * 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 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.
      */
-    private hash;
+    protected _stringHash(key: string): number;
     /**
-     * The put function adds a key-value pair to a hash table, handling collisions by chaining.
+     * 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;
+    /**
+     * 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;
+    set(key: K, val: V): void;
     /**
      * 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;
     /**
-     * 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;
+    /**
+     * 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;
+    get size(): number;
 }