graph-typed 2.0.4 → 2.1.0

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

@@ -1,12 +1,17 @@
 /**
  * data-structure-typed
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ *
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
 import { IterableElementBase } from '../base';
 /**
+ * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @template R
  * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
  * 2. Heap Properties: Each node in a heap follows a specific order property, which varies depending on the type of heap:
  * Max Heap: The value of each parent node is greater than or equal to the value of its children.
@@ -183,222 +188,230 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export declare class Heap<E = any, R = any> extends IterableElementBase<E, R> {
-    /**
-     * 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> | Iterable<R>, options?: HeapOptions<E, R>);
+export declare class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+    protected _equals: (a: E, b: E) => boolean;
+    /**
+     * Create a Heap and optionally bulk-insert elements.
+     * @remarks Time O(N), Space O(N)
+     * @param [elements] - Iterable of elements (or raw values if toElementFn is set).
+     * @param [options] - Options such as comparator and toElementFn.
+     * @returns New Heap instance.
+     */
+    constructor(elements?: Iterable<E | R>, options?: HeapOptions<E, R>);
     protected _elements: E[];
     /**
-     * The function returns an array of elements.
-     * @returns The element array is being returned.
+     * Get the backing array of the heap.
+     * @remarks Time O(1), Space O(1)
+     * @returns Internal elements array.
      */
     get elements(): E[];
     /**
-     * Get the size (number of elements) of the heap.
+     * Get the number of elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Heap size.
      */
     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 the last leaf element.
+     * @remarks Time O(1), Space O(1)
+     * @returns Last element or undefined.
      */
     get leaf(): E | undefined;
     /**
-     * Static method that creates a binary heap from an array of elements and a comparison function.
-     * @returns A new Heap instance.
-     * @param elements
-     * @param options
+     * Create a heap of the same class from an iterable.
+     * @remarks Time O(N), Space O(N)
+     * @template T
+     * @template R
+     * @template S
+     * @param [elements] - Iterable of elements or raw records.
+     * @param [options] - Heap options including comparator.
+     * @returns A new heap instance of this class.
+     */
+    static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S, elements?: Iterable<T | R>, options?: HeapOptions<T, R>): S;
+    /**
+     * Build a Heap from an iterable in linear time given a comparator.
+     * @remarks Time O(N), Space O(N)
+     * @template EE
+     * @template RR
+     * @param elements - Iterable of elements.
+     * @param options - Heap options including comparator.
+     * @returns A new Heap built from elements.
      */
-    static heapify<E = any, R = any>(elements: Iterable<E>, options: HeapOptions<E, R>): Heap<E>;
+    static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR>;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The add function pushes an element into an array and then triggers a bubble-up operation.
-     * @param {E} element - The `element` parameter represents the element that you want to add to the
-     * data structure.
-     * @returns The `add` method is returning a boolean value, which is the result of calling the
-     * `_bubbleUp` method with the index `this.elements.length - 1` as an argument.
+     * Insert an element.
+     * @remarks Time O(1) amortized, Space O(1)
+     * @param element - Element to insert.
+     * @returns True.
      */
     add(element: E): boolean;
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The `addMany` function iterates over elements and adds them to a collection, returning an array of
-     * boolean values indicating success or failure.
-     * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the `addMany` method is
-     * an iterable containing elements of type `E` or `R`. The method iterates over each element in the
-     * iterable and adds them to the data structure. If a transformation function `_toElementFn` is
-     * provided, it transforms the element
-     * @returns The `addMany` method returns an array of boolean values indicating whether each element
-     * in the input iterable was successfully added to the data structure.
-     */
-    addMany(elements: Iterable<E> | Iterable<R>): boolean[];
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * Insert many elements from an iterable.
+     * @remarks Time O(N log N), Space O(1)
+     * @param elements - Iterable of elements or raw values.
+     * @returns Array of per-element success flags.
+     */
+    addMany(elements: Iterable<E | R>): boolean[];
+    /**
+     * Remove and return the top element.
+     * @remarks Time O(log N), Space O(1)
+     * @returns Top element or undefined.
      */
     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.
+     * Get the current top element without removing it.
+     * @remarks Time O(1), Space O(1)
+     * @returns Top element or undefined.
      */
     peek(): E | undefined;
     /**
-     * Check if the heap is empty.
-     * @returns True if the heap is empty, otherwise false.
+     * Check whether the heap is empty.
+     * @remarks Time O(1), Space O(1)
+     * @returns True if size is 0.
      */
     isEmpty(): boolean;
     /**
-     * Reset the elements of the heap. Make the elements empty.
+     * Remove all elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
      */
     clear(): void;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Clear and add elements of the heap
-     * @param elements
+     * Replace the backing array and rebuild the heap.
+     * @remarks Time O(N), Space O(N)
+     * @param elements - Iterable used to refill the heap.
+     * @returns Array of per-node results from fixing steps.
      */
-    refill(elements: E[]): boolean[];
+    refill(elements: Iterable<E>): boolean[];
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * Use a comparison function to check whether a binary heap contains a specific element.
-     * @param element - the element to check.
-     * @returns Returns true if the specified element is contained; otherwise, returns false.
+     * Check if an equal element exists in the heap.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to search for.
+     * @returns True if found.
      */
     has(element: E): boolean;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `delete` function removes an element from an array-like data structure, maintaining the order
-     * and structure of the remaining elements.
-     * @param {E} element - The `element` parameter represents the element that you want to delete from
-     * the array `this.elements`.
-     * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
-     * successfully deleted from the array, and `false` if the element was not found in the array.
+     * Delete one occurrence of an element.
+     * @remarks Time O(N), Space O(1)
+     * @param element - Element to delete.
+     * @returns True if an element was removed.
      */
     delete(element: E): boolean;
     /**
-     * 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).
-     * @returns An array containing elements traversed in the specified order.
+     * Delete the first element that matches a predicate.
+     * @remarks Time O(N), Space O(1)
+     * @param predicate - Function (element, index, heap) → boolean.
+     * @returns True if an element was removed.
+     */
+    deleteBy(predicate: (element: E, index: number, heap: this) => boolean): boolean;
+    /**
+     * Set the equality comparator used by has/delete operations.
+     * @remarks Time O(1), Space O(1)
+     * @param equals - Equality predicate (a, b) → boolean.
+     * @returns This heap.
+     */
+    setEquality(equals: (a: E, b: E) => boolean): this;
+    /**
+     * Traverse the binary heap as a complete binary tree and collect elements.
+     * @remarks Time O(N), Space O(H)
+     * @param [order] - Traversal order: 'PRE' | 'IN' | 'POST'.
+     * @returns Array of visited elements.
      */
     dfs(order?: DFSOrderPattern): E[];
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * Clone the heap, creating a new heap with the same elements.
-     * @returns A new Heap instance containing the same elements.
+     * Restore heap order bottom-up (heapify in-place).
+     * @remarks Time O(N), Space O(1)
+     * @returns Array of per-node results from fixing steps.
      */
-    clone(): Heap<E, R>;
+    fix(): boolean[];
     /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * Sort the elements in the heap and return them as an array.
-     * @returns An array containing the elements sorted in ascending order.
+     * Return all elements in ascending order by repeatedly polling.
+     * @remarks Time O(N log N), Space O(N)
+     * @returns Sorted array of elements.
      */
     sort(): E[];
     /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * Fix the entire heap to maintain heap properties.
+     * Deep clone this heap.
+     * @remarks Time O(N), Space O(N)
+     * @returns A new heap with the same elements.
      */
-    fix(): boolean[];
+    clone(): this;
+    /**
+     * Filter elements into a new heap of the same class.
+     * @remarks Time O(N log N), Space O(N)
+     * @param callback - Predicate (element, index, heap) → boolean to keep element.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new heap with the kept elements.
+     */
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: unknown): this;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `filter` function creates a new Heap object containing elements that pass a given callback
-     * function.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: the current element, the index of the current element, and the
-     * heap itself. The callback function should return a boolean value indicating whether the current
-     * element should be included in the filtered list
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
-     * the filter condition specified by the `callback` function.
-     */
-    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new heap by applying a callback function to each element of the
-     * original heap.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
-     * element), and `this` (the heap itself). The callback function should return a value of
-     * @param comparator - The `comparator` parameter is a function that defines the order of the
-     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
-     * if `a` should be placed before `b`, a positive number if `a` should be placed after
-     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
-     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
-     * returns a value of type `T`. This function is used to transform the elements of the original
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used to set the context or scope
-     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
-     * value of
-     * @returns a new instance of the `Heap` class with the mapped elements.
-     */
-    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Heap<EM, RM>;
+     * Map elements into a new heap of possibly different element type.
+     * @remarks Time O(N log N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param callback - Mapping function (element, index, heap) → newElement.
+     * @param options - Options for the output heap, including comparator for EM.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new heap with mapped elements.
+     */
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, options: HeapOptions<EM, RM> & {
+        comparator: Comparator<EM>;
+    }, thisArg?: unknown): Heap<EM, RM>;
+    /**
+     * Map elements into a new heap of the same element type.
+     * @remarks Time O(N log N), Space O(N)
+     * @param callback - Mapping function (element, index, heap) → element.
+     * @param [thisArg] - Value for `this` inside the callback.
+     * @returns A new heap with mapped elements.
+     */
+    mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
     protected _DEFAULT_COMPARATOR: (a: E, b: E) => number;
-    protected _comparator: Comparator<E>;
+    protected _comparator: Comparator<E>; /**
+     * Get the comparator used to order elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Comparator function.
+     */
     /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
+     * Get the comparator used to order elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Comparator function.
      */
     get comparator(): Comparator<E>;
+    protected _getIterator(): IterableIterator<E>;
+    protected _bubbleUp(index: number): boolean;
+    protected _sinkDown(index: number, halfLength: number): boolean;
     /**
-     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     * (Protected) Create an empty instance of the same concrete class.
+     * @remarks Time O(1), Space O(1)
+     * @param [options] - Options to override comparator or toElementFn.
+     * @returns A like-kind empty heap instance.
      */
-    protected _getIterator(): IterableIterator<E>;
+    protected _createInstance(options?: HeapOptions<E, R>): this;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
+     * (Protected) Create a like-kind instance seeded by elements.
+     * @remarks Time O(N log N), Space O(N)
+     * @template EM
+     * @template RM
+     * @param [elements] - Iterable of elements or raw values to seed.
+     * @param [options] - Options forwarded to the constructor.
+     * @returns A like-kind heap instance.
      */
-    protected _bubbleUp(index: number): boolean;
+    protected _createLike<EM, RM>(elements?: Iterable<EM> | Iterable<RM>, options?: HeapOptions<EM, RM>): Heap<EM, RM>;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * Sinking operation to maintain heap properties after removing the top element.
-     * @param index - The index from which to start sinking.
-     * @param halfLength
+     * (Protected) Spawn an empty like-kind heap instance.
+     * @remarks Time O(1), Space O(1)
+     * @template EM
+     * @template RM
+     * @param [options] - Options forwarded to the constructor.
+     * @returns An empty like-kind heap instance.
      */
-    protected _sinkDown(index: number, halfLength: number): boolean;
+    protected _spawnLike<EM, RM>(options?: HeapOptions<EM, RM>): Heap<EM, RM>;
 }
+/**
+ * Node container used by FibonacciHeap.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ */
 export declare class FibonacciHeapNode<E> {
     element: E;
     degree: number;
@@ -407,172 +420,84 @@ 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);
 }
+/**
+ * Fibonacci heap (min-heap) optimized for fast merges and amortized operations.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ * @example examples will be generated by unit test
+ */
 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.
+     * Create a FibonacciHeap.
+     * @remarks Time O(1), Space O(1)
+     * @param [comparator] - Comparator to order elements (min-heap by default).
+     * @returns New FibonacciHeap instance.
      */
     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 the circular root list head.
+     * @remarks Time O(1), Space O(1)
+     * @returns Root node 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 the current minimum node.
+     * @remarks Time O(1), Space O(1)
+     * @returns Min node or 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.
-     * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
-     */
     clear(): void;
+    add(element: E): boolean;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element
-     * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
-     */
-    add(element: E): FibonacciHeap<E>;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Insert an element into the heap and maintain the heap properties.
-     * @param element
-     * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
-     */
-    push(element: E): FibonacciHeap<E>;
-    /**
-     * 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.
-     * @protected
+     * Push an element into the root list.
+     * @remarks Time O(1) amortized, Space O(1)
+     * @param element - Element to insert.
+     * @returns This heap.
      */
+    push(element: E): this;
     peek(): E | undefined;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * Get the size (number of elements) of the heap.
-     * @param {FibonacciHeapNode<E>} head - The head of the linked list.
-     * @protected
-     * @returns FibonacciHeapNode<E>[] - An array containing the elements of the linked list.
+     * Collect nodes from a circular doubly linked list starting at head.
+     * @remarks Time O(K), Space O(K)
+     * @param [head] - Start node of the circular list.
+     * @returns Array of nodes from the list.
      */
     consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * @param parent
-     * @param node
+     * Insert a node into a parent's child list (circular).
+     * @remarks Time O(1), Space O(1)
+     * @param parent - Parent node.
+     * @param node - Child node to insert.
+     * @returns void
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
-     */
     poll(): E | undefined;
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @returns The top element or undefined if the heap is empty.
+     * Remove and return the minimum element, consolidating the root list.
+     * @remarks Time O(log N) amortized, Space O(1)
+     * @returns Minimum element or undefined.
      */
     pop(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
-     * @param heapToMerge
+     * Meld another heap into this heap.
+     * @remarks Time O(1), Space O(1)
+     * @param heapToMerge - Another FibonacciHeap to meld into this one.
+     * @returns void
      */
     merge(heapToMerge: FibonacciHeap<E>): void;
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    createNode(element: E): FibonacciHeapNode<E>;
-    /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
-     * @protected
-     */
+    _createNode(element: E): FibonacciHeapNode<E>;
+    isEmpty(): boolean;
     protected _defaultComparator(a: E, b: E): number;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Merge the given node with the root list.
-     * @param node - The node to be merged.
-     */
     protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @param node - The node to be removed.
-     * @protected
-     */
     protected removeFromRoot(node: FibonacciHeapNode<E>): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @param y
-     * @param x
-     * @protected
-     */
     protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * Remove and return the top element (the smallest or largest element) from the heap.
-     * @protected
-     */
     protected _consolidate(): void;
 }