min-heap-typed 1.50.2 → 1.50.3

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

@@ -45,6 +45,22 @@ class HashMap extends base_1.IterableEntryBase {
             this.setMany(rawCollection);
         }
     }
+    /**
+     * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
+     * @returns The store property is being returned. It is a dictionary-like object with string keys and
+     * values of type HashMapStoreItem<K, V>.
+     */
+    get store() {
+        return this._store;
+    }
+    /**
+     * The function returns the object map.
+     * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
+     * `object` and values of type `V`.
+     */
+    get objMap() {
+        return this._objMap;
+    }
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
@@ -52,22 +68,22 @@ class HashMap extends base_1.IterableEntryBase {
     get toEntryFn() {
         return this._toEntryFn;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
+    get size() {
+        return this._size;
+    }
     /**
      * The hasFn function is a function that takes in an item and returns a boolean
      * indicating whether the item is contained within the hash table.
      *
      * @return The hash function
      */
-    get hasFn() {
+    get hashFn() {
         return this._hashFn;
     }
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size() {
-        return this._size;
-    }
     /**
      * The function checks if a given element is an array with exactly two elements.
      * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
@@ -104,14 +120,14 @@ class HashMap extends base_1.IterableEntryBase {
      */
     set(key, value) {
         if (this._isObjKey(key)) {
-            if (!this._objMap.has(key)) {
+            if (!this.objMap.has(key)) {
                 this._size++;
             }
-            this._objMap.set(key, value);
+            this.objMap.set(key, value);
         }
         else {
             const strKey = this._getNoObjKey(key);
-            if (this._store[strKey] === undefined) {
+            if (this.store[strKey] === undefined) {
                 this._size++;
             }
             this._store[strKey] = { key, value };
@@ -153,7 +169,7 @@ class HashMap extends base_1.IterableEntryBase {
     get(key) {
         var _a;
         if (this._isObjKey(key)) {
-            return this._objMap.get(key);
+            return this.objMap.get(key);
         }
         else {
             const strKey = this._getNoObjKey(key);
@@ -168,11 +184,11 @@ class HashMap extends base_1.IterableEntryBase {
      */
     has(key) {
         if (this._isObjKey(key)) {
-            return this._objMap.has(key);
+            return this.objMap.has(key);
         }
         else {
             const strKey = this._getNoObjKey(key);
-            return strKey in this._store;
+            return strKey in this.store;
         }
     }
     /**
@@ -184,21 +200,25 @@ class HashMap extends base_1.IterableEntryBase {
      */
     delete(key) {
         if (this._isObjKey(key)) {
-            if (this._objMap.has(key)) {
+            if (this.objMap.has(key)) {
                 this._size--;
             }
-            return this._objMap.delete(key);
+            return this.objMap.delete(key);
         }
         else {
             const strKey = this._getNoObjKey(key);
-            if (strKey in this._store) {
-                delete this._store[strKey];
+            if (strKey in this.store) {
+                delete this.store[strKey];
                 this._size--;
                 return true;
             }
             return false;
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     /**
      * The clone function creates a new HashMap with the same key-value pairs as
      * this one. The clone function is useful for creating a copy of an existing
@@ -207,7 +227,7 @@ class HashMap extends base_1.IterableEntryBase {
      * @return A new hashmap with the same values as this one
      */
     clone() {
-        return new HashMap(this, { hashFn: this._hashFn, toEntryFn: this.toEntryFn });
+        return new HashMap(this, { hashFn: this.hashFn, toEntryFn: this.toEntryFn });
     }
     /**
      * Time Complexity: O(n)
@@ -235,10 +255,6 @@ class HashMap extends base_1.IterableEntryBase {
         }
         return resultMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -281,22 +297,34 @@ class HashMap extends base_1.IterableEntryBase {
      * object map.
      */
     *_getIterator() {
-        for (const node of Object.values(this._store)) {
+        for (const node of Object.values(this.store)) {
             yield [node.key, node.value];
         }
-        for (const node of this._objMap) {
+        for (const node of this.objMap) {
             yield node;
         }
     }
+    /**
+     * The function checks if a given key is an object or a function.
+     * @param {any} key - The parameter "key" can be of any type.
+     * @returns a boolean value.
+     */
     _isObjKey(key) {
         const keyType = typeof key;
         return (keyType === 'object' || keyType === 'function') && key !== null;
     }
+    /**
+     * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
+     * different types of keys.
+     * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
+     * passed to the `_getNoObjKey` function.
+     * @returns a string value.
+     */
     _getNoObjKey(key) {
         const keyType = typeof key;
         let strKey;
         if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-            strKey = this._hashFn(key);
+            strKey = this.hashFn(key);
         }
         else {
             if (keyType === 'number') {
@@ -328,6 +356,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      */
     constructor(rawCollection = [], options) {
         super();
+        this._hashFn = (key) => String(key);
+        this._objHashFn = (key) => key;
         this._noObjMap = {};
         this._objMap = new WeakMap();
         this._toEntryFn = (rawElement) => {
@@ -340,8 +370,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             }
         };
         this._size = 0;
-        this._hashFn = (key) => String(key);
-        this._objHashFn = (key) => key;
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
         if (options) {
@@ -361,6 +389,51 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             }
         }
     }
+    /**
+     * The function returns the hash function used for generating a hash value for a given key.
+     * @returns The hash function that takes a key of type K and returns a string.
+     */
+    get hashFn() {
+        return this._hashFn;
+    }
+    /**
+     * The function returns the object hash function.
+     * @returns The function `objHashFn` is being returned.
+     */
+    get objHashFn() {
+        return this._objHashFn;
+    }
+    /**
+     * The function returns a record of HashMapLinkedNode objects with string keys.
+     * @returns The method is returning a Record object, which is a TypeScript type that represents an
+     * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
+     * values of type V or undefined.
+     */
+    get noObjMap() {
+        return this._noObjMap;
+    }
+    /**
+     * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
+     * @returns The `objMap` property is being returned.
+     */
+    get objMap() {
+        return this._objMap;
+    }
+    /**
+     * The function returns the head node of a HashMapLinkedNode.
+     * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
+     * value type `V | undefined`.
+     */
+    get head() {
+        return this._head;
+    }
+    /**
+     * The function returns the tail node of a HashMapLinkedNode.
+     * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
+     */
+    get tail() {
+        return this._tail;
+    }
     /**
      * The function returns the value of the _toEntryFn property.
      * @returns The function being returned is `this._toEntryFn`.
@@ -375,6 +448,10 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     get size() {
         return this._size;
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -386,8 +463,12 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     get first() {
         if (this._size === 0)
             return;
-        return [this._head.key, this._head.value];
+        return [this.head.key, this.head.value];
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -399,13 +480,13 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     get last() {
         if (this._size === 0)
             return;
-        return [this._tail.key, this._tail.value];
+        return [this.tail.key, this.tail.value];
     }
     /**
      * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
      */
     *begin() {
-        let node = this._head;
+        let node = this.head;
         while (node !== this._sentinel) {
             yield [node.key, node.value];
             node = node.next;
@@ -416,12 +497,16 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * key and value.
      */
     *reverseBegin() {
-        let node = this._tail;
+        let node = this.tail;
         while (node !== this._sentinel) {
             yield [node.key, node.value];
             node = node.prev;
         }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -438,12 +523,12 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         let node;
         const isNewKey = !this.has(key); // Check if the key is new
         if ((0, utils_1.isWeakKey)(key)) {
-            const hash = this._objHashFn(key);
-            node = this._objMap.get(hash);
+            const hash = this.objHashFn(key);
+            node = this.objMap.get(hash);
             if (!node && isNewKey) {
                 // Create new node
-                node = { key: hash, value, prev: this._tail, next: this._sentinel };
-                this._objMap.set(hash, node);
+                node = { key: hash, value, prev: this.tail, next: this._sentinel };
+                this.objMap.set(hash, node);
             }
             else if (node) {
                 // Update the value of an existing node
@@ -451,10 +536,10 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             }
         }
         else {
-            const hash = this._hashFn(key);
-            node = this._noObjMap[hash];
+            const hash = this.hashFn(key);
+            node = this.noObjMap[hash];
             if (!node && isNewKey) {
-                this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+                this.noObjMap[hash] = node = { key, value, prev: this.tail, next: this._sentinel };
             }
             else if (node) {
                 // Update the value of an existing node
@@ -468,8 +553,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
                 this._sentinel.next = node;
             }
             else {
-                this._tail.next = node;
-                node.prev = this._tail; // Make sure that the prev of the new node points to the current tail node
+                this.tail.next = node;
+                node.prev = this.tail; // Make sure that the prev of the new node points to the current tail node
             }
             this._tail = node;
             this._sentinel.prev = node;
@@ -501,14 +586,18 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      */
     has(key) {
         if ((0, utils_1.isWeakKey)(key)) {
-            const hash = this._objHashFn(key);
-            return this._objMap.has(hash);
+            const hash = this.objHashFn(key);
+            return this.objMap.has(hash);
         }
         else {
-            const hash = this._hashFn(key);
-            return hash in this._noObjMap;
+            const hash = this.hashFn(key);
+            return hash in this.noObjMap;
         }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -524,18 +613,23 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      */
     get(key) {
         if ((0, utils_1.isWeakKey)(key)) {
-            const hash = this._objHashFn(key);
-            const node = this._objMap.get(hash);
+            const hash = this.objHashFn(key);
+            const node = this.objMap.get(hash);
             return node ? node.value : undefined;
         }
         else {
-            const hash = this._hashFn(key);
-            const node = this._noObjMap[hash];
+            const hash = this.hashFn(key);
+            const node = this.noObjMap[hash];
             return node ? node.value : undefined;
         }
     }
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The function `at` retrieves the key-value pair at a specified index in a linked list.
@@ -547,13 +641,18 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      */
     at(index) {
         (0, utils_1.rangeCheck)(index, 0, this._size - 1);
-        let node = this._head;
+        let node = this.head;
         while (index--) {
             node = node.next;
         }
         return node.value;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -566,30 +665,35 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     delete(key) {
         let node;
         if ((0, utils_1.isWeakKey)(key)) {
-            const hash = this._objHashFn(key);
+            const hash = this.objHashFn(key);
             // Get nodes from WeakMap
-            node = this._objMap.get(hash);
+            node = this.objMap.get(hash);
             if (!node) {
                 return false; // If the node does not exist, return false
             }
             // Remove nodes from WeakMap
-            this._objMap.delete(hash);
+            this.objMap.delete(hash);
         }
         else {
-            const hash = this._hashFn(key);
+            const hash = this.hashFn(key);
             // Get nodes from noObjMap
-            node = this._noObjMap[hash];
+            node = this.noObjMap[hash];
             if (!node) {
                 return false; // If the node does not exist, return false
             }
             // Remove nodes from orgMap
-            delete this._noObjMap[hash];
+            delete this.noObjMap[hash];
         }
         // Remove node from doubly linked list
         this._deleteNode(node);
         return true;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -600,13 +704,18 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      */
     deleteAt(index) {
         (0, utils_1.rangeCheck)(index, 0, this._size - 1);
-        let node = this._head;
+        let node = this.head;
         while (index--) {
             node = node.next;
         }
         return this._deleteNode(node);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -627,6 +736,11 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return Array.isArray(rawElement) && rawElement.length === 2;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
@@ -651,7 +765,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * of the original `LinkedHashMap` object.
      */
     clone() {
-        const cloned = new LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+        const cloned = new LinkedHashMap([], { hashFn: this.hashFn, objHashFn: this.objHashFn });
         for (const entry of this) {
             const [key, value] = entry;
             cloned.set(key, value);
@@ -659,6 +773,11 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return cloned;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -685,6 +804,11 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return filteredMap;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
@@ -730,6 +854,12 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return this.set(key, value);
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * where n is the number of entries in the LinkedHashMap.
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      * where n is the number of entries in the LinkedHashMap.
@@ -737,12 +867,16 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
     *_getIterator() {
-        let node = this._head;
+        let node = this.head;
         while (node !== this._sentinel) {
             yield [node.key, node.value];
             node = node.next;
         }
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -757,10 +891,10 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         const { prev, next } = node;
         prev.next = next;
         next.prev = prev;
-        if (node === this._head) {
+        if (node === this.head) {
             this._head = next;
         }
-        if (node === this._tail) {
+        if (node === this.tail) {
             this._tail = prev;
         }
         this._size -= 1;

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

@@ -86,6 +86,10 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @returns The top element or undefined if the heap is empty.
      */
     poll(): E | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -104,11 +108,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     clear(): void;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * Clear and add elements of the heap
@@ -116,11 +120,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     refill(elements: E[]): boolean[];
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -129,11 +133,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     has(element: E): boolean;
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
+     * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
      */
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -145,12 +150,13 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     delete(element: E): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     * where log n is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
      * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
@@ -194,12 +200,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     sort(): E[];
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * Fix the entire heap to maintain heap properties.
      */
@@ -255,7 +261,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     protected _getIterator(): IterableIterator<E>;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -266,6 +272,10 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index of the newly added element.
      */
     protected _bubbleUp(index: number): boolean;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -397,11 +407,11 @@ export declare class FibonacciHeap<E> {
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -409,11 +419,11 @@ export declare class FibonacciHeap<E> {
      */
     poll(): E | undefined;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.