min-heap-typed 1.50.0 → 1.50.2

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

@@ -25,13 +25,42 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `T`. It is an optional parameter and its default value is an empty array `[]`.
      * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(rawCollection?: Iterable<R>, options?: HashMapOptions<K, V, R>);
+    constructor(rawCollection?: Iterable<R | [K, V]>, options?: HashMapOptions<K, V, R>);
     protected _toEntryFn: (rawElement: R) => [K, V];
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
     get toEntryFn(): (rawElement: R) => [K, V];
+    /**
+     * 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(): (key: K) => string;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
+    /**
+     * 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
+     * data type.
+     * @returns a boolean value.
+     */
     isEntry(rawElement: any): rawElement is [K, V];
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
+     */
     isEmpty(): boolean;
+    /**
+     * The clear() function resets the state of an object by clearing its internal store, object map, and
+     * size.
+     */
     clear(): void;
     /**
      * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
@@ -50,7 +79,7 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * `T`.
      * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(rawCollection: Iterable<R>): boolean[];
+    setMany(rawCollection: Iterable<R | [K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -75,6 +104,14 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * successfully deleted from the map, and `false` if the key was not found in the map.
      */
     delete(key: K): boolean;
+    /**
+     * 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
+     * HashMap, and then modifying that copy without affecting the original.
+     *
+     * @return A new hashmap with the same values as this one
+     */
+    clone(): HashMap<K, V, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -115,6 +152,14 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * from the original `HashMap` that pass the provided `predicate` function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
+    /**
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
+     */
     put(key: K, value: V): boolean;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
@@ -130,14 +175,33 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
  * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of entries through the linked list.
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
-export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
     protected _head: HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
-    constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>);
+    /**
+     * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
+     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * then added to the HashMap
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
+     */
+    constructor(rawCollection?: Iterable<R>, options?: LinkedHashMapOptions<K, V, R>);
+    protected _toEntryFn: (rawElement: R) => [K, V];
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn(): (rawElement: R) => [K, V];
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object.
+     */
     get size(): number;
     /**
      * Time Complexity: O(1)
@@ -179,8 +243,22 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * @returns the size of the data structure after the key-value pair has been set.
      */
     set(key: K, value?: V): boolean;
+    /**
+     * The function `setMany` takes an iterable collection, converts each element into a key-value pair
+     * using a provided function, and sets each key-value pair in the current object, returning an array
+     * of booleans indicating the success of each set operation.
+     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * R.
+     * @returns The `setMany` function returns an array of booleans.
+     */
+    setMany(rawCollection: Iterable<R>): boolean[];
+    /**
+     * The function checks if a given key exists in a map, using different logic depending on whether the
+     * key is a weak key or not.
+     * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
+     * @returns The method `has` is returning a boolean value.
+     */
     has(key: K): boolean;
-    setMany(entries: Iterable<[K, V]>): boolean[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -199,14 +277,14 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
      *
-     * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+     * The function `at` retrieves the key-value pair at a specified index in a linked list.
      * @param {number} index - The index parameter is a number that represents the position of the
      * element we want to retrieve from the data structure.
-     * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index: number): V | undefined;
+    at(index: number): V | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -219,7 +297,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     delete(key: K): boolean;
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `deleteAt` function deletes a node at a specified index in a linked list.
@@ -237,6 +315,13 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * not.
      */
     isEmpty(): boolean;
+    /**
+     * 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
+     * data type.
+     * @returns a boolean value.
+     */
+    isEntry(rawElement: any): rawElement is [K, V];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -244,6 +329,19 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear(): void;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
+     * the original.
+     * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
+     * of the original `LinkedHashMap` object.
+     */
     clone(): LinkedHashMap<K, V>;
     /**
      * Time Complexity: O(n)
@@ -280,19 +378,27 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
-    put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
      */
+    put(key: K, value: V): boolean;
     protected _hashFn: (key: K) => string;
     protected _objHashFn: (key: K) => object;
     /**
-     * Time Complexity: O(n), 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.
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */

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

@@ -45,18 +45,49 @@ class HashMap extends base_1.IterableEntryBase {
             this.setMany(rawCollection);
         }
     }
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
     get toEntryFn() {
         return this._toEntryFn;
     }
+    /**
+     * 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() {
+        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
+     * data type.
+     * @returns a boolean value.
+     */
     isEntry(rawElement) {
         return Array.isArray(rawElement) && rawElement.length === 2;
     }
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
+     */
     isEmpty() {
         return this.size === 0;
     }
+    /**
+     * The clear() function resets the state of an object by clearing its internal store, object map, and
+     * size.
+     */
     clear() {
         this._store = {};
         this._objMap.clear();
@@ -97,7 +128,16 @@ class HashMap extends base_1.IterableEntryBase {
     setMany(rawCollection) {
         const results = [];
         for (const rawEle of rawCollection) {
-            const [key, value] = this.toEntryFn(rawEle);
+            let key, value;
+            if (this.isEntry(rawEle)) {
+                key = rawEle[0];
+                value = rawEle[1];
+            }
+            else {
+                const item = this.toEntryFn(rawEle);
+                key = item[0];
+                value = item[1];
+            }
             results.push(this.set(key, value));
         }
         return results;
@@ -159,6 +199,16 @@ class HashMap extends base_1.IterableEntryBase {
             return false;
         }
     }
+    /**
+     * 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
+     * HashMap, and then modifying that copy without affecting the original.
+     *
+     * @return A new hashmap with the same values as this one
+     */
+    clone() {
+        return new HashMap(this, { hashFn: this._hashFn, toEntryFn: this.toEntryFn });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -215,6 +265,14 @@ class HashMap extends base_1.IterableEntryBase {
         }
         return filteredMap;
     }
+    /**
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
+     */
     put(key, value) {
         return this.set(key, value);
     }
@@ -259,32 +317,61 @@ exports.HashMap = HashMap;
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 class LinkedHashMap extends base_1.IterableEntryBase {
-    constructor(entries, options) {
+    /**
+     * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements. It is
+     * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
+     * `rawCollection` is converted to a key-value pair using the `toEntryFn` function (if provided) and
+     * then added to the HashMap
+     * @param [options] - The `options` parameter is an optional object that can contain the following
+     * properties:
+     */
+    constructor(rawCollection = [], options) {
         super();
         this._noObjMap = {};
         this._objMap = new WeakMap();
+        this._toEntryFn = (rawElement) => {
+            if (this.isEntry(rawElement)) {
+                // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+                return rawElement;
+            }
+            else {
+                throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
+            }
+        };
         this._size = 0;
-        /**
-         * Time Complexity: O(n)
-         * Space Complexity: O(n)
-         */
         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) {
-            const { hashFn, objHashFn } = options;
+            const { hashFn, objHashFn, toEntryFn } = options;
             if (hashFn)
                 this._hashFn = hashFn;
             if (objHashFn)
                 this._objHashFn = objHashFn;
+            if (toEntryFn) {
+                this._toEntryFn = toEntryFn;
+            }
         }
-        if (entries) {
-            for (const el of entries) {
-                this.set(el[0], el[1]);
+        if (rawCollection) {
+            for (const el of rawCollection) {
+                const [key, value] = this.toEntryFn(el);
+                this.set(key, value);
             }
         }
     }
+    /**
+     * The function returns the value of the _toEntryFn property.
+     * @returns The function being returned is `this._toEntryFn`.
+     */
+    get toEntryFn() {
+        return this._toEntryFn;
+    }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object.
+     */
     get size() {
         return this._size;
     }
@@ -390,6 +477,28 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return true;
     }
+    /**
+     * The function `setMany` takes an iterable collection, converts each element into a key-value pair
+     * using a provided function, and sets each key-value pair in the current object, returning an array
+     * of booleans indicating the success of each set operation.
+     * @param rawCollection - The rawCollection parameter is an iterable collection of elements of type
+     * R.
+     * @returns The `setMany` function returns an array of booleans.
+     */
+    setMany(rawCollection) {
+        const results = [];
+        for (const rawEle of rawCollection) {
+            const [key, value] = this.toEntryFn(rawEle);
+            results.push(this.set(key, value));
+        }
+        return results;
+    }
+    /**
+     * The function checks if a given key exists in a map, using different logic depending on whether the
+     * key is a weak key or not.
+     * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
+     * @returns The method `has` is returning a boolean value.
+     */
     has(key) {
         if ((0, utils_1.isWeakKey)(key)) {
             const hash = this._objHashFn(key);
@@ -400,14 +509,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             return hash in this._noObjMap;
         }
     }
-    setMany(entries) {
-        const results = [];
-        for (const entry of entries) {
-            const [key, value] = entry;
-            results.push(this.set(key, value));
-        }
-        return results;
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -437,14 +538,14 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
      *
-     * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+     * The function `at` retrieves the key-value pair at a specified index in a linked list.
      * @param {number} index - The index parameter is a number that represents the position of the
      * element we want to retrieve from the data structure.
-     * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+     * @returns The method `at(index: number)` is returning an array containing the key-value pair at
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index) {
+    at(index) {
         (0, utils_1.rangeCheck)(index, 0, this._size - 1);
         let node = this._head;
         while (index--) {
@@ -489,7 +590,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return true;
     }
     /**
-     * Time Complexity: O(n), where n is the index.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * The `deleteAt` function deletes a node at a specified index in a linked list.
@@ -516,6 +617,15 @@ class LinkedHashMap extends base_1.IterableEntryBase {
     isEmpty() {
         return this._size === 0;
     }
+    /**
+     * 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
+     * data type.
+     * @returns a boolean value.
+     */
+    isEntry(rawElement) {
+        return Array.isArray(rawElement) && rawElement.length === 2;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -527,6 +637,19 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         this._size = 0;
         this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
+     * the original.
+     * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
+     * of the original `LinkedHashMap` object.
+     */
     clone() {
         const cloned = new LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
         for (const entry of this) {
@@ -589,15 +712,27 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         return mappedMap;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The put function sets a value in a data structure using a specified key.
+     * @param {K} key - The key parameter is of type K, which represents the type of the key being passed
+     * to the function.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * specified key in the data structure.
+     * @returns The method is returning a boolean value.
      */
     put(key, value) {
         return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), 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.
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */

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

@@ -19,10 +19,28 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export declare class Heap<E = any> extends IterableElementBase<E> {
+    /**
+     * The constructor initializes a heap data structure with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable object that contains the initial
+     * elements to be added to the heap. It is an optional parameter and if not provided, the heap will
+     * be initialized as empty.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the heap. In this case, it is used to specify a custom comparator
+     * function for comparing elements in the heap. The comparator function is used to determine the
+     * order of elements in the heap.
+     */
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
     protected _comparator: (a: E, b: E) => number;
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
     get comparator(): (a: E, b: E) => number;
     protected _elements: E[];
+    /**
+     * The function returns an array of elements.
+     * @returns The elements array is being returned.
+     */
     get elements(): E[];
     /**
      * Get the size (number of elements) of the heap.
@@ -43,11 +61,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
         comparator: Comparator<E>;
     }): Heap<E>;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -55,11 +74,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     add(element: E): boolean;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * 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.
@@ -67,6 +87,9 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     poll(): E | undefined;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -227,6 +250,9 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * original Heap.
      */
     map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
+    /**
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(n)
@@ -258,17 +284,51 @@ export declare class FibonacciHeapNode<E> {
     child?: FibonacciHeapNode<E>;
     parent?: FibonacciHeapNode<E>;
     marked: boolean;
+    /**
+     * The constructor function initializes an object with an element and a degree, and sets the marked
+     * property to false.
+     * @param {E} element - The "element" parameter represents the value or data that will be stored in
+     * the node of a data structure. It can be any type of data, such as a number, string, object, or
+     * even another data structure.
+     * @param [degree=0] - The degree parameter represents the degree of the element in a data structure
+     * called a Fibonacci heap. The degree of a node is the number of children it has. By default, the
+     * degree is set to 0 when a new node is created.
+     */
     constructor(element: E, degree?: number);
 }
 export declare class FibonacciHeap<E> {
+    /**
+     * The constructor function initializes a FibonacciHeap object with an optional comparator function.
+     * @param [comparator] - The `comparator` parameter is an optional argument that represents a
+     * function used to compare elements in the FibonacciHeap. If a comparator function is provided, it
+     * will be used to determine the order of elements in the heap. If no comparator function is
+     * provided, a default comparator function will be used.
+     */
     constructor(comparator?: Comparator<E>);
     protected _root?: FibonacciHeapNode<E>;
+    /**
+     * The function returns the root node of a Fibonacci heap.
+     * @returns The method is returning either a FibonacciHeapNode object or undefined.
+     */
     get root(): FibonacciHeapNode<E> | undefined;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     protected _min?: FibonacciHeapNode<E>;
+    /**
+     * The function returns the minimum node in a Fibonacci heap.
+     * @returns The method is returning the minimum node of the Fibonacci heap, which is of type
+     * `FibonacciHeapNode<E>`. If there is no minimum node, it will return `undefined`.
+     */
     get min(): FibonacciHeapNode<E> | undefined;
     protected _comparator: Comparator<E>;
+    /**
+     * The function returns the comparator used for comparing elements.
+     * @returns The `_comparator` property of the object.
+     */
     get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
@@ -425,11 +485,11 @@ export declare class FibonacciHeap<E> {
      */
     protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.