avl-tree-typed 2.0.5 → 2.1.0

package/src/data-structures/heap/heap.ts

@@ -1,7 +1,8 @@
 /**
  * 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
  */
 
@@ -9,6 +10,10 @@ import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '
 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.
@@ -185,21 +190,18 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export 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 class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+  protected _equals: (a: E, b: E) => boolean = Object.is;
+
+  /**
+   * 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>) {
     super(options);
 
     if (options) {
@@ -207,91 +209,113 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
       if (comparator) this._comparator = comparator;
     }
 
-    this.addMany(elements);
+    this.addMany(elements as Iterable<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[] {
     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(): number {
     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(): E | undefined {
     return this.elements[this.size - 1] ?? 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 {
+    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<E = any, R = any>(elements: Iterable<E>, options: HeapOptions<E, R>): Heap<E> {
-    return new Heap<E>(elements, options);
+
+  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+    return new Heap<EE, RR>(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: E): boolean {
-    this._elements.push(element as E);
+    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: Iterable<E> | Iterable<R>): boolean[] {
-    const ans: boolean[] = [];
+
+  addMany(elements: Iterable<E | R>): boolean[] {
+    const flags: boolean[] = [];
     for (const el of elements) {
-      if (this._toElementFn) {
-        ans.push(this.add(this._toElementFn(el as R)));
-        continue;
+      if (this.toElementFn) {
+        const ok = this.add(this.toElementFn(el as R));
+        flags.push(ok);
+      } else {
+        const ok = this.add(el as E);
+        flags.push(ok);
       }
-      ans.push(this.add(el as E));
     }
-    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(): E | undefined {
     if (this.elements.length === 0) return;
     const value = this.elements[0];
@@ -304,68 +328,74 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   }
 
   /**
-   * 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 {
     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(): boolean {
     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(): void {
     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: E[]): boolean[] {
-    this._elements = elements;
+
+  refill(elements: Iterable<E>): boolean[] {
+    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.
    */
+
   override has(element: E): boolean {
-    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: E): boolean {
-    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) {
       this.poll();
@@ -380,17 +410,54 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   }
 
   /**
-   * 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 {
+    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: (a: E, b: E) => boolean): this {
+    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: DFSOrderPattern = 'PRE'): E[] {
     const result: E[] = [];
-
-    // Auxiliary recursive function, traverses the binary heap according to the traversal order
     const _dfs = (index: number) => {
       const left = 2 * index + 1,
         right = left + 1;
@@ -410,153 +477,147 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
         }
       }
     };
-
-    _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(): Heap<E, R> {
-    return new Heap<E, R>(this, { comparator: this.comparator, toElementFn: this.toElementFn });
+
+  fix(): boolean[] {
+    const results: boolean[] = [];
+    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(): E[] {
-    const visitedNode: E[] = [];
-    const cloned = new Heap<E, R>(this, { comparator: this.comparator });
-    while (cloned.size !== 0) {
+    const visited: E[] = [];
+    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);
+      if (top !== undefined) 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(): boolean[] {
-    const results: boolean[] = [];
-    for (let i = Math.floor(this.size / 2); i >= 0; i--) results.push(this._sinkDown(i, this.elements.length >> 1));
-    return results;
+
+  clone(): this {
+    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(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R> {
-    const filteredList = new Heap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
-    let index = 0;
-    for (const current of this) {
-      if (callback.call(thisArg, current, index, this)) {
-        filteredList.add(current);
+   * 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 {
+    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.
+    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<EM, RM>(
     callback: ElementCallback<E, R, EM>,
-    comparator: Comparator<EM>,
-    toElementFn?: (rawElement: RM) => EM,
-    thisArg?: any
+    options: HeapOptions<EM, RM> & { comparator: Comparator<EM> },
+    thisArg?: unknown
   ): Heap<EM, RM> {
-    const mappedHeap: Heap<EM, RM> = new Heap<EM, RM>([], { comparator, toElementFn });
-    let index = 0;
-    for (const el of this) {
-      mappedHeap.add(callback.call(thisArg, el, index, this));
-      index++;
+    const { comparator, toElementFn, ...rest } = options ?? {};
+    if (!comparator) throw new TypeError('Heap.map requires options.comparator for EM');
+    const out = this._createLike<EM, RM>([], { ...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;
+  }
+
+  /**
+   * 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 {
+    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;
   }
 
   protected _DEFAULT_COMPARATOR = (a: E, b: E): number => {
     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;
-    if (a < b) return -1;
+    if ((a as unknown as number) > (b as unknown as number)) return 1;
+    if ((a as unknown as number) < (b as unknown as number)) return -1;
     return 0;
   };
 
-  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;
-
+  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR; /**
+   * 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() {
     return this._comparator;
   }
 
-  /**
-   * The function `_getIterator` returns an iterable iterator for the elements in the class.
-   */
   protected *_getIterator(): IterableIterator<E> {
-    for (const element of this.elements) {
-      yield element;
-    }
+    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.
-   */
   protected _bubbleUp(index: number): boolean {
     const element = this.elements[index];
     while (index > 0) {
@@ -570,14 +631,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     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
-   */
   protected _sinkDown(index: number, halfLength: number): boolean {
     const element = this.elements[index];
     while (index < halfLength) {
@@ -595,8 +648,57 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     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.
+   */
+
+  protected _createInstance(options?: HeapOptions<E, R>): this {
+    const Ctor: any = this.constructor;
+    const next: any = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
+    return next as this;
+  }
+
+  /**
+   * (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 _createLike<EM, RM>(
+    elements: Iterable<EM> | Iterable<RM> = [],
+    options?: HeapOptions<EM, RM>
+  ): Heap<EM, RM> {
+    const Ctor: any = this.constructor;
+    return new Ctor(elements, options) as Heap<EM, RM>;
+  }
+
+  /**
+   * (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 _spawnLike<EM, RM>(options?: HeapOptions<EM, RM>): Heap<EM, RM> {
+    return this._createLike<EM, RM>([], options);
+  }
 }
 
+/**
+ * Node container used by FibonacciHeap.
+ * @remarks Time O(1), Space O(1)
+ * @template E
+ */
 export class FibonacciHeapNode<E> {
   element: E;
   degree: number;
@@ -606,16 +708,6 @@ export class 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 = 0) {
     this.element = element;
     this.degree = degree;
@@ -623,39 +715,39 @@ export class FibonacciHeapNode<E> {
   }
 }
 
+/**
+ * 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 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>) {
     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.');
   }
 
   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 {
     return this._root;
   }
 
   protected _size = 0;
-
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
   get size(): number {
     return this._size;
   }
@@ -663,120 +755,84 @@ export class FibonacciHeap<E> {
   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 {
     return this._min;
   }
 
   protected _comparator: Comparator<E>;
-
-  /**
-   * The function returns the comparator used for comparing elements.
-   * @returns The `_comparator` property of the object.
-   */
   get comparator(): Comparator<E> {
     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(): void {
     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: E): FibonacciHeap<E> {
-    return this.push(element);
+  add(element: E): boolean {
+    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: E): FibonacciHeap<E> {
-    const node = this.createNode(element);
+
+  push(element: E): this {
+    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) {
-      this._min = node;
-    }
-
+    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(): E | undefined {
     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?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[] {
     const elements: FibonacciHeapNode<E>[] = [];
     if (!head) return elements;
-
     let node: FibonacciHeapNode<E> | undefined = head;
-    let flag = false;
-
+    let started = false;
     while (true) {
-      if (node === head && flag) break;
-      else if (node === head) flag = true;
-
-      if (node) {
-        elements.push(node);
-        node = node.right;
-      }
+      if (node === head && started) break;
+      else if (node === head) 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: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void {
-    if (!parent.child) {
-      parent.child = node;
-    } else {
+    if (!parent.child) parent.child = node;
+    else {
       node.right = parent.child.right;
       node.left = parent.child;
       parent.child.right!.left = node;
@@ -784,27 +840,18 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * 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 {
     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(): E | undefined {
     if (this._size === 0) return undefined;
-
     const z = this.min!;
     if (z.child) {
       const elements = this.consumeLinkedList(z.child);
@@ -813,9 +860,7 @@ export class FibonacciHeap<E> {
         node.parent = undefined;
       }
     }
-
     this.removeFromRoot(z);
-
     if (z === z.right) {
       this._min = undefined;
       this._root = undefined;
@@ -823,83 +868,55 @@ export class FibonacciHeap<E> {
       this._min = z.right;
       this._consolidate();
     }
-
     this._size--;
-
     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: FibonacciHeap<E>): void {
-    if (heapToMerge.size === 0) {
-      return; // Nothing to merge
-    }
 
-    // Merge the root lists of the two heaps
+  merge(heapToMerge: FibonacciHeap<E>): void {
+    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;
+    } else if (!this.root && heapToMerge.root) {
+      this._root = heapToMerge.root;
     }
-
-    // Update the minimum node
     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: E): FibonacciHeapNode<E> {
+  _createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 
-  /**
-   * Default comparator function used by the heap.
-   * @param {E} a
-   * @param {E} b
-   * @protected
-   */
+  isEmpty(): boolean {
+    return this._size === 0;
+  }
+
   protected _defaultComparator(a: E, b: E): number {
     if (a < b) return -1;
     if (a > b) 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.
-   */
   protected mergeWithRoot(node: FibonacciHeapNode<E>): void {
-    if (!this.root) {
-      this._root = node;
-    } else {
+    if (!this.root) this._root = node;
+    else {
       node.right = this.root.right;
       node.left = this.root;
       this.root.right!.left = node;
@@ -907,29 +924,12 @@ export class FibonacciHeap<E> {
     }
   }
 
-  /**
-   * 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 {
     if (this.root === node) this._root = node.right;
     if (node.left) node.left.right = node.right;
     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
-   */
   protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void {
     this.removeFromRoot(y);
     y.left = y;
@@ -939,13 +939,6 @@ export class FibonacciHeap<E> {
     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
-   */
   protected _consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this._size);
     const elements = this.consumeLinkedList(this.root);
@@ -957,28 +950,22 @@ export class FibonacciHeap<E> {
     for (const node of elements) {
       x = node;
       d = x.degree;
-
       while (A[d]) {
         y = A[d] as FibonacciHeapNode<E>;
-
         if (this.comparator(x.element, y.element) > 0) {
           t = x;
           x = y;
           y = t;
         }
-
         this._link(y, x);
         A[d] = undefined;
         d++;
       }
-
       A[d] = x;
     }
 
-    for (let i = 0; i < this._size; i++) {
-      if (A[i] && this.comparator(A[i]!.element, this.min!.element) <= 0) {
-        this._min = A[i]!;
-      }
+    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]!;
     }
   }
 }