heap-typed 1.38.0 → 1.38.2

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

@@ -13,19 +13,46 @@ export declare class HashTableNode<K, V> {
 }
 import { HashFunction } from '../../types';
 export declare class HashTable<K, V> {
-    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;
+    constructor(capacity?: number, hashFn?: HashFunction<K>);
     private _capacity;
+    get capacity(): number;
+    set capacity(value: number);
     private _size;
+    get size(): number;
     private _buckets;
+    get buckets(): Array<HashTableNode<K, V> | null>;
+    set buckets(value: Array<HashTableNode<K, V> | null>);
     private _hashFn;
-    constructor(capacity?: number, hashFn?: HashFunction<K>);
+    get hashFn(): HashFunction<K>;
+    set hashFn(value: HashFunction<K>);
+    /**
+     * 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 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.
+     */
+    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 `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 delete 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 `delete` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    delete(key: K): void;
     /**
      * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
      * capacity of the data structure.
@@ -71,36 +98,9 @@ export declare class HashTable<K, V> {
      * @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 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.
-     */
-    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 `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 delete 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 `delete` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    delete(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;
 }

package/dist/data-structures/hash/hash-table.js

@@ -17,113 +17,32 @@ class HashTableNode {
 }
 exports.HashTableNode = HashTableNode;
 class HashTable {
-    get hashFn() {
-        return this._hashFn;
-    }
-    set hashFn(value) {
-        this._hashFn = value;
-    }
-    get buckets() {
-        return this._buckets;
-    }
-    set buckets(value) {
-        this._buckets = value;
-    }
-    get capacity() {
-        return this._capacity;
-    }
-    set capacity(value) {
-        this._capacity = value;
-    }
     constructor(capacity = HashTable.DEFAULT_CAPACITY, hashFn) {
         this._hashFn = hashFn || this._defaultHashFn;
         this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
         this._size = 0;
         this._buckets = new Array(this._capacity).fill(null);
     }
-    /**
-     * 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.
-     */
-    _defaultHashFn(key) {
-        // Can be replaced with other hash functions as needed
-        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
-        return hashValue % this._capacity;
+    get capacity() {
+        return 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.
-     */
-    _multiplicativeStringHashFn(key) {
-        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
+    set capacity(value) {
+        this._capacity = value;
     }
-    /**
-     * 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.
-     */
-    _murmurStringHashFn(key) {
-        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);
+    get size() {
+        return this._size;
     }
-    /**
-     * 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.
-     */
-    _hash(key) {
-        return this.hashFn(key);
+    get buckets() {
+        return this._buckets;
     }
-    /**
-     * 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.
-     */
-    _stringHash(key) {
-        let hash = 0;
-        for (let i = 0; i < key.length; i++) {
-            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
-        }
-        return hash;
+    set buckets(value) {
+        this._buckets = value;
     }
-    /**
-     * 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.
-     */
-    _objectHash(key) {
-        // 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));
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
     }
     /**
      * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
@@ -208,6 +127,90 @@ class HashTable {
             currentNode = currentNode.next;
         }
     }
+    /**
+     * 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.
+     */
+    _defaultHashFn(key) {
+        // 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.
+     */
+    _multiplicativeStringHashFn(key) {
+        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.
+     */
+    _murmurStringHashFn(key) {
+        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.
+     */
+    _hash(key) {
+        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.
+     */
+    _stringHash(key) {
+        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.
+     */
+    _objectHash(key) {
+        // 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.
@@ -236,9 +239,6 @@ class HashTable {
         this._buckets = newBuckets;
         this._capacity = newCapacity;
     }
-    get size() {
-        return this._size;
-    }
 }
 exports.HashTable = HashTable;
 HashTable.DEFAULT_CAPACITY = 16;

package/dist/data-structures/heap/heap.d.ts

@@ -9,6 +9,22 @@ export declare class Heap<E> {
     protected nodes: E[];
     protected readonly comparator: Comparator<E>;
     constructor(comparator: Comparator<E>);
+    /**
+     * Get the size (number of elements) of the heap.
+     */
+    get size(): number;
+    /**
+     * 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;
+    /**
+     * 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>;
     /**
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
@@ -29,34 +45,11 @@ export declare class Heap<E> {
      * @returns The top element or undefined if the heap is empty.
      */
     pop(): E | undefined;
-    /**
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
-     */
-    protected bubbleUp(index: number): void;
-    /**
-     * 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;
-    /**
-     * Fix the entire heap to maintain heap properties.
-     */
-    protected fix(): void;
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
      */
     peek(): E | undefined;
-    /**
-     * Get the size (number of elements) of the heap.
-     */
-    get size(): number;
-    /**
-     * 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;
     /**
      * Check if the heap is empty.
      * @returns True if the heap is empty, otherwise false.
@@ -100,12 +93,19 @@ export declare class Heap<E> {
      */
     sort(): 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>;
+    protected bubbleUp(index: number): void;
+    /**
+     * 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;
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
 }
 export declare class FibonacciHeapNode<E> {
     element: E;
@@ -119,33 +119,15 @@ export declare class FibonacciHeapNode<E> {
 }
 export declare class FibonacciHeap<E> {
     root?: FibonacciHeapNode<E>;
-    protected min?: FibonacciHeapNode<E>;
     size: number;
+    protected min?: FibonacciHeapNode<E>;
     protected readonly comparator: Comparator<E>;
     constructor(comparator?: Comparator<E>);
-    /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
-     * @protected
-     */
-    protected defaultComparator(a: E, b: E): number;
     /**
      * 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.
      */
     clear(): void;
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    protected createNode(element: E): FibonacciHeapNode<E>;
-    /**
-     * Merge the given node with the root list.
-     * @param node - The node to be merged.
-     */
-    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(1) time operation.
      * Insert an element into the heap and maintain the heap properties.
@@ -175,13 +157,6 @@ export declare class FibonacciHeap<E> {
      * @returns FibonacciHeapNode<E>[] - An array containing the nodes of the linked list.
      */
     consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
-    /**
-     * 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;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -192,33 +167,58 @@ export declare 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
+     * @returns The top element or undefined if the heap is empty.
      */
-    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
+    poll(): E | undefined;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
+     * @param heapToMerge
+     */
+    merge(heapToMerge: FibonacciHeap<E>): void;
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
      * @protected
      */
-    protected consolidate(): void;
+    protected defaultComparator(a: E, b: E): number;
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    protected createNode(element: E): FibonacciHeapNode<E>;
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * @param node - The node to be removed.
+     * @protected
      */
-    poll(): E | undefined;
+    protected removeFromRoot(node: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * @param y
+     * @param x
+     * @protected
      */
-    pop(): E | undefined;
+    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
      * O(log n) time operation.
-     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
-     * @param heapToMerge
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
      */
-    merge(heapToMerge: FibonacciHeap<E>): void;
+    protected consolidate(): void;
 }