doubly-linked-list-typed 2.0.5 → 2.1.1

package/dist/data-structures/heap/heap.js

@@ -1,14 +1,30 @@
 "use strict";
 /**
  * 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
  */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 const base_1 = require("../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.
@@ -187,24 +203,19 @@ const base_1 = require("../base");
  */
 class Heap extends base_1.IterableElementBase {
     /**
-     * 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.
+     * 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 = [], options) {
         super(options);
+        this._equals = Object.is;
         this._elements = [];
         this._DEFAULT_COMPARATOR = (a, b) => {
             if (typeof a === 'object' || typeof b === 'object') {
-                throw TypeError(`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`);
+                throw TypeError('When comparing object types, define a custom comparator in options.');
             }
             if (a > b)
                 return 1;
@@ -212,7 +223,11 @@ class Heap extends base_1.IterableElementBase {
                 return -1;
             return 0;
         };
-        this._comparator = this._DEFAULT_COMPARATOR;
+        this._comparator = this._DEFAULT_COMPARATOR; /**
+         * Get the comparator used to order elements.
+         * @remarks Time O(1), Space O(1)
+         * @returns Comparator function.
+         */
         if (options) {
             const { comparator } = options;
             if (comparator)
@@ -221,79 +236,89 @@ class Heap extends base_1.IterableElementBase {
         this.addMany(elements);
     }
     /**
-     * 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() {
         return this._elements;
     }
     /**
-     * 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() {
         return this.elements.length;
     }
     /**
-     * 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() {
         var _a;
         return (_a = this.elements[this.size - 1]) !== null && _a !== void 0 ? _a : 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(elements, options) {
+        return new this(elements, options);
+    }
+    /**
+     * 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(elements, options) {
         return new Heap(elements, options);
     }
     /**
-     * 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) {
         this._elements.push(element);
         return this._bubbleUp(this.elements.length - 1);
     }
     /**
-     * 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.
+     * 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) {
-        const ans = [];
+        const flags = [];
         for (const el of elements) {
-            if (this._toElementFn) {
-                ans.push(this.add(this._toElementFn(el)));
-                continue;
+            if (this.toElementFn) {
+                const ok = this.add(this.toElementFn(el));
+                flags.push(ok);
+            }
+            else {
+                const ok = this.add(el);
+                flags.push(ok);
             }
-            ans.push(this.add(el));
         }
-        return ans;
+        return flags;
     }
     /**
-     * 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 top element.
+     * @remarks Time O(log N), Space O(1)
+     * @returns Top element or undefined.
      */
     poll() {
         if (this.elements.length === 0)
@@ -307,63 +332,65 @@ class Heap extends base_1.IterableElementBase {
         return value;
     }
     /**
-     * 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() {
         return this.elements[0];
     }
     /**
-     * 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() {
         return this.size === 0;
     }
     /**
-     * Reset the elements of the heap. Make the elements empty.
+     * Remove all elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns void
      */
     clear() {
         this._elements = [];
     }
     /**
-     * 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) {
-        this._elements = elements;
+        this._elements = Array.from(elements);
         return this.fix();
     }
     /**
-     * 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) {
-        return this.elements.includes(element);
+        for (const el of this.elements)
+            if (this._equals(el, element))
+                return true;
+        return false;
     }
     /**
-     * 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) {
-        const index = this.elements.indexOf(element);
+        let index = -1;
+        for (let i = 0; i < this.elements.length; i++) {
+            if (this._equals(this.elements[i], element)) {
+                index = i;
+                break;
+            }
+        }
         if (index < 0)
             return false;
         if (index === 0) {
@@ -380,16 +407,52 @@ class Heap extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * 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) {
+        let idx = -1;
+        for (let i = 0; i < this.elements.length; i++) {
+            if (predicate(this.elements[i], i, this)) {
+                idx = i;
+                break;
+            }
+        }
+        if (idx < 0)
+            return false;
+        if (idx === 0) {
+            this.poll();
+        }
+        else if (idx === this.elements.length - 1) {
+            this.elements.pop();
+        }
+        else {
+            this.elements.splice(idx, 1, this.elements.pop());
+            this._bubbleUp(idx);
+            this._sinkDown(idx, this.elements.length >> 1);
+        }
+        return true;
+    }
+    /**
+     * 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) {
+        this._equals = equals;
+        return 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 = 'PRE') {
         const result = [];
-        // Auxiliary recursive function, traverses the binary heap according to the traversal order
         const _dfs = (index) => {
             const left = 2 * index + 1, right = left + 1;
             if (index < this.size) {
@@ -410,127 +473,119 @@ class Heap extends base_1.IterableElementBase {
                 }
             }
         };
-        _dfs(0); // Traverse starting from the root node
+        _dfs(0);
         return result;
     }
     /**
-     * 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() {
-        return new Heap(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+    fix() {
+        const results = [];
+        for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {
+            results.push(this._sinkDown(i, this.elements.length >> 1));
+        }
+        return results;
     }
     /**
-     * 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() {
-        const visitedNode = [];
-        const cloned = new Heap(this, { comparator: this.comparator });
-        while (cloned.size !== 0) {
+        const visited = [];
+        const cloned = this._createInstance();
+        for (const x of this.elements)
+            cloned.add(x);
+        while (!cloned.isEmpty()) {
             const top = cloned.poll();
             if (top !== undefined)
-                visitedNode.push(top);
+                visited.push(top);
         }
-        return visitedNode;
+        return visited;
     }
     /**
-     * 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() {
-        const results = [];
-        for (let i = Math.floor(this.size / 2); i >= 0; i--)
-            results.push(this._sinkDown(i, this.elements.length >> 1));
-        return results;
+    clone() {
+        const next = this._createInstance();
+        for (const x of this.elements)
+            next.add(x);
+        return next;
     }
     /**
-     * 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 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, thisArg) {
-        const filteredList = new Heap([], { toElementFn: this.toElementFn, comparator: this.comparator });
-        let index = 0;
-        for (const current of this) {
-            if (callback.call(thisArg, current, index, this)) {
-                filteredList.add(current);
+        const out = this._createInstance();
+        let i = 0;
+        for (const x of this) {
+            if (thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {
+                out.add(x);
+            }
+            else {
+                i++;
             }
-            index++;
         }
-        return filteredList;
-    }
-    /**
-     * 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(callback, comparator, toElementFn, thisArg) {
-        const mappedHeap = new Heap([], { comparator, toElementFn });
-        let index = 0;
-        for (const el of this) {
-            mappedHeap.add(callback.call(thisArg, el, index, this));
-            index++;
+        return out;
+    }
+    /**
+     * 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(callback, options, thisArg) {
+        const _a = options !== null && options !== void 0 ? options : {}, { comparator, toElementFn } = _a, rest = __rest(_a, ["comparator", "toElementFn"]);
+        if (!comparator)
+            throw new TypeError('Heap.map requires options.comparator for EM');
+        const out = this._createLike([], Object.assign(Object.assign({}, rest), { comparator, toElementFn }));
+        let i = 0;
+        for (const x of this) {
+            const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+            out.add(v);
         }
-        return mappedHeap;
+        return out;
     }
     /**
-     * The function returns the value of the _comparator property.
-     * @returns The `_comparator` property is being returned.
+     * 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.
      */
-    get comparator() {
-        return this._comparator;
+    mapSame(callback, thisArg) {
+        const out = this._createInstance();
+        let i = 0;
+        for (const x of this) {
+            const v = thisArg === undefined ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+            out.add(v);
+        }
+        return out;
     }
     /**
-     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     * Get the comparator used to order elements.
+     * @remarks Time O(1), Space O(1)
+     * @returns Comparator function.
      */
+    get comparator() {
+        return this._comparator;
+    }
     *_getIterator() {
-        for (const element of this.elements) {
+        for (const element of this.elements)
             yield element;
-        }
     }
-    /**
-     * 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.
-     */
     _bubbleUp(index) {
         const element = this.elements[index];
         while (index > 0) {
@@ -544,14 +599,6 @@ class Heap extends base_1.IterableElementBase {
         this.elements[index] = element;
         return true;
     }
-    /**
-     * 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
-     */
     _sinkDown(index, halfLength) {
         const element = this.elements[index];
         while (index < halfLength) {
@@ -570,19 +617,49 @@ class Heap extends base_1.IterableElementBase {
         this.elements[index] = element;
         return true;
     }
+    /**
+     * (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.
+     */
+    _createInstance(options) {
+        const Ctor = this.constructor;
+        const next = new Ctor([], Object.assign({ comparator: this.comparator, toElementFn: this.toElementFn }, (options !== null && options !== void 0 ? options : {})));
+        return next;
+    }
+    /**
+     * (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.
+     */
+    _createLike(elements = [], options) {
+        const Ctor = this.constructor;
+        return new Ctor(elements, options);
+    }
+    /**
+     * (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.
+     */
+    _spawnLike(options) {
+        return this._createLike([], options);
+    }
 }
 exports.Heap = Heap;
+/**
+ * Node container used by FibonacciHeap.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ */
 class FibonacciHeapNode {
-    /**
-     * 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, degree = 0) {
         this.element = element;
         this.degree = degree;
@@ -590,139 +667,108 @@ class FibonacciHeapNode {
     }
 }
 exports.FibonacciHeapNode = FibonacciHeapNode;
+/**
+ * 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
+ */
 class FibonacciHeap {
     /**
-     * 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) {
         this._size = 0;
         this.clear();
         this._comparator = comparator || this._defaultComparator;
-        if (typeof this.comparator !== 'function') {
-            throw new Error('FibonacciHeap constructor: given comparator should be a function.');
-        }
+        if (typeof this.comparator !== 'function')
+            throw new Error('FibonacciHeap: comparator must be a function.');
     }
     /**
-     * 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() {
         return this._root;
     }
-    /**
-     * 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 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() {
         return this._min;
     }
-    /**
-     * The function returns the comparator used for comparing elements.
-     * @returns The `_comparator` property of the object.
-     */
     get comparator() {
         return this._comparator;
     }
-    /**
-     * 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() {
         this._root = undefined;
         this._min = undefined;
         this._size = 0;
     }
-    /**
-     * 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) {
-        return this.push(element);
+        this.push(element);
+        return true;
     }
     /**
-     * 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 an element into the root list.
+     * @remarks Time O(1) amortized, Space O(1)
+     * @param element - Element to insert.
+     * @returns This heap.
      */
     push(element) {
-        const node = this.createNode(element);
+        const node = this._createNode(element);
         node.left = node;
         node.right = node;
         this.mergeWithRoot(node);
-        if (!this.min || this.comparator(node.element, this.min.element) <= 0) {
+        if (!this.min || this.comparator(node.element, this.min.element) <= 0)
             this._min = node;
-        }
         this._size++;
         return this;
     }
-    /**
-     * 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
-     */
     peek() {
         return this.min ? this.min.element : 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) {
         const elements = [];
         if (!head)
             return elements;
         let node = head;
-        let flag = false;
+        let started = false;
         while (true) {
-            if (node === head && flag)
+            if (node === head && started)
                 break;
             else if (node === head)
-                flag = true;
-            if (node) {
-                elements.push(node);
-                node = node.right;
-            }
+                started = true;
+            elements.push(node);
+            node = node.right;
         }
         return elements;
     }
     /**
-     * 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, node) {
-        if (!parent.child) {
+        if (!parent.child)
             parent.child = node;
-        }
         else {
             node.right = parent.child.right;
             node.left = parent.child;
@@ -730,22 +776,13 @@ class FibonacciHeap {
             parent.child.right = node;
         }
     }
-    /**
-     * 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() {
         return this.pop();
     }
     /**
-     * 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() {
         if (this._size === 0)
@@ -771,50 +808,37 @@ class FibonacciHeap {
         return z.element;
     }
     /**
-     * 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) {
-        if (heapToMerge.size === 0) {
-            return; // Nothing to merge
-        }
-        // Merge the root lists of the two heaps
+        if (heapToMerge.size === 0)
+            return;
         if (this.root && heapToMerge.root) {
-            const thisRoot = this.root;
-            const otherRoot = heapToMerge.root;
-            const thisRootRight = thisRoot.right;
-            const otherRootLeft = otherRoot.left;
+            const thisRoot = this.root, otherRoot = heapToMerge.root;
+            const thisRootRight = thisRoot.right, otherRootLeft = otherRoot.left;
             thisRoot.right = otherRoot;
             otherRoot.left = thisRoot;
             thisRootRight.left = otherRootLeft;
             otherRootLeft.right = thisRootRight;
         }
-        // Update the minimum node
+        else if (!this.root && heapToMerge.root) {
+            this._root = heapToMerge.root;
+        }
         if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {
             this._min = heapToMerge.min;
         }
-        // Update the size
         this._size += heapToMerge.size;
-        // Clear the heap that was merged
         heapToMerge.clear();
     }
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    createNode(element) {
+    _createNode(element) {
         return new FibonacciHeapNode(element);
     }
-    /**
-     * Default comparator function used by the heap.
-     * @param {E} a
-     * @param {E} b
-     * @protected
-     */
+    isEmpty() {
+        return this._size === 0;
+    }
     _defaultComparator(a, b) {
         if (a < b)
             return -1;
@@ -822,17 +846,9 @@ class FibonacciHeap {
             return 1;
         return 0;
     }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * Merge the given node with the root list.
-     * @param node - The node to be merged.
-     */
     mergeWithRoot(node) {
-        if (!this.root) {
+        if (!this.root)
             this._root = node;
-        }
         else {
             node.right = this.root.right;
             node.left = this.root;
@@ -840,14 +856,6 @@ class FibonacciHeap {
             this.root.right = node;
         }
     }
-    /**
-     * 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
-     */
     removeFromRoot(node) {
         if (this.root === node)
             this._root = node.right;
@@ -856,15 +864,6 @@ class FibonacciHeap {
         if (node.right)
             node.right.left = node.left;
     }
-    /**
-     * 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
-     */
     _link(y, x) {
         this.removeFromRoot(y);
         y.left = y;
@@ -873,13 +872,6 @@ class FibonacciHeap {
         x.degree++;
         y.parent = x;
     }
-    /**
-     * 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
-     */
     _consolidate() {
         const A = new Array(this._size);
         const elements = this.consumeLinkedList(this.root);
@@ -900,10 +892,9 @@ class FibonacciHeap {
             }
             A[d] = x;
         }
-        for (let i = 0; i < this._size; i++) {
-            if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
+        for (let i = 0; i < A.length; i++) {
+            if (A[i] && (!this.min || this.comparator(A[i].element, this.min.element) <= 0))
                 this._min = A[i];
-            }
         }
     }
 }