data-structure-typed 1.35.1 → 1.36.1

package/lib/data-structures/binary-tree/bst.d.ts

@@ -9,7 +9,7 @@ import type { BinaryTreeNodeKey, BinaryTreeNodePropertyName, BSTComparator, BSTN
 import { CP } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../../interfaces';
-export declare class BSTNode<V = any, NEIGHBOR extends BSTNode<V, NEIGHBOR> = BSTNodeNested<V>> extends BinaryTreeNode<V, NEIGHBOR> implements IBSTNode<V, NEIGHBOR> {
+export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> implements IBSTNode<V, FAMILY> {
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
 import { IRBTree, IRBTreeNode } from '../../interfaces';
 import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IRBTreeNode<V, NEIGHBOR> {
+export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> implements IRBTreeNode<V, FAMILY> {
     private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
     get color(): RBColor;

package/lib/data-structures/binary-tree/tree-multiset.d.ts

@@ -9,7 +9,7 @@ import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } f
 import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIGHBOR> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, NEIGHBOR> implements ITreeMultisetNode<V, NEIGHBOR> {
+export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> implements ITreeMultisetNode<V, FAMILY> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier

package/lib/data-structures/graph/abstract-graph.js

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import { arrayRemove, uuidV4 } from '../../utils';
@@ -523,9 +523,7 @@ export class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new PriorityQueue({
-            comparator: (a, b) => a.key - b.key
-        });
+        const heap = new PriorityQueue((a, b) => a.key - b.key);
         heap.add({ key: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);

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

@@ -1,83 +1,99 @@
 /**
  * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-export declare class HeapItem<V = any> {
-    /**
-     * The constructor function initializes an instance of a class with a priority and a value.
-     * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
-     * optional and has a default value of `NaN`.
-     * @param {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
-     * `V` or `null`.
-     */
-    constructor(priority?: number, val?: V | null);
-    private _priority;
-    get priority(): number;
-    set priority(value: number);
-    private _val;
-    get val(): V | null;
-    set val(value: V | null);
-}
-export declare abstract class Heap<V = any> {
+import type { CompareFunction } from '../../types';
+export declare class Heap<E> {
+    protected nodes: E[];
+    private readonly comparator;
+    constructor(comparator: CompareFunction<E>);
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param value - The element to be inserted.
+     */
+    add(value: E): Heap<E>;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or null if the heap is empty.
+     */
+    poll(): E | null;
+    /**
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
+     */
+    protected bubbleUp(index: number): void;
     /**
-     * The function is a constructor for a class that initializes a priority callback function based on the
-     * options provided.
-     * @param [options] - An optional object that contains configuration options for the Heap.
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
      */
-    protected constructor(options?: HeapOptions<V>);
-    protected abstract _pq: PriorityQueue<HeapItem<V>>;
-    get pq(): PriorityQueue<HeapItem<V>>;
-    protected _priorityExtractor: (val: V) => number;
-    get priorityExtractor(): (val: V) => number;
+    protected sinkDown(index: number): void;
     /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
+    /**
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or null if the heap is empty.
+     */
+    peek(): E | null;
+    /**
+     * Get the size (number of elements) of the heap.
      */
     get size(): number;
     /**
-     * The function checks if a priority queue is empty.
-     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or null if the heap is empty.
+     */
+    get leaf(): E | null;
+    /**
+     * Check if the heap is empty.
+     * @returns True if the heap is empty, otherwise false.
      */
     isEmpty(): boolean;
-    peek(isItem?: undefined): V | undefined;
-    peek(isItem: false): V | undefined;
-    peek(isItem: true): HeapItem<V> | null;
-    peekLast(isItem?: undefined): V | undefined;
-    peekLast(isItem: false): V | undefined;
-    peekLast(isItem: true): HeapItem<V> | null;
-    /**
-     * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {V} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
-     * type.
-     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
-     * the value of `val`. If the `val` parameter is not a number, then the
-     * @returns The `add` method returns the instance of the `Heap` class.
-     * @throws {Error} if priority is not a valid number
-     */
-    add(priority: number, val?: V): Heap<V>;
-    poll(isItem?: undefined): V | undefined;
-    poll(isItem: false): V | undefined;
-    poll(isItem: true): HeapItem<V> | null;
-    /**
-     * The function checks if a given node or value exists in the priority queue.
-     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
-     * @returns a boolean value.
-     */
-    has(node: V | HeapItem<V>): boolean;
-    toArray(isItem?: undefined): (V | undefined)[];
-    toArray(isItem: false): (V | undefined)[];
-    toArray(isItem: true): (HeapItem<V> | null)[];
-    sort(isItem?: undefined): (V | undefined)[];
-    sort(isItem: false): (V | undefined)[];
-    sort(isItem: true): (HeapItem<V> | null)[];
-    /**
-     * The clear function clears the priority queue.
+    /**
+     * Reset the nodes of the heap. Make the nodes empty.
      */
     clear(): void;
+    /**
+     * Clear and add nodes of the heap
+     * @param nodes
+     */
+    refill(nodes: E[]): void;
+    /**
+     * Use a comparison function to check whether a binary heap contains a specific element.
+     * @param value - the element to check.
+     * @returns Returns true if the specified element is contained; otherwise, returns false.
+     */
+    has(value: E): boolean;
+    /**
+     * Depth-first search (DFS) method, different traversal orders can be selected。
+     * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @returns An array containing elements traversed in the specified order.
+     */
+    dfs(order: 'in' | 'pre' | 'post'): E[];
+    /**
+     * Convert the heap to an array.
+     * @returns An array containing the elements of the heap.
+     */
+    toArray(): E[];
+    getNodes(): E[];
+    /**
+     * Clone the heap, creating a new heap with the same elements.
+     * @returns A new Heap instance containing the same elements.
+     */
+    clone(): Heap<E>;
+    /**
+     * Sort the elements in the heap and return them as an array.
+     * @returns An array containing the elements sorted in ascending order.
+     */
+    sort(): E[];
+    /**
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @param nodes
+     * @param comparator - Comparison function.
+     * @returns A new Heap instance.
+     */
+    static heapify<E>(nodes: E[], comparator: CompareFunction<E>): Heap<E>;
 }

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

@@ -1,152 +1,213 @@
-export class HeapItem {
+/**
+ * data-structure-typed
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+export class Heap {
+    constructor(comparator) {
+        this.nodes = [];
+        this.comparator = comparator;
+    }
     /**
-     * The constructor function initializes an instance of a class with a priority and a value.
-     * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
-     * optional and has a default value of `NaN`.
-     * @param {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
-     * `V` or `null`.
+     * Insert an element into the heap and maintain the heap properties.
+     * @param value - The element to be inserted.
      */
-    constructor(priority = Number.MAX_SAFE_INTEGER, val = null) {
-        this._val = val;
-        this._priority = priority;
-    }
-    get priority() {
-        return this._priority;
-    }
-    set priority(value) {
-        this._priority = value;
-    }
-    get val() {
-        return this._val;
+    add(value) {
+        this.nodes.push(value);
+        this.bubbleUp(this.nodes.length - 1);
+        return this;
     }
-    set val(value) {
-        this._val = value;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or null if the heap is empty.
+     */
+    poll() {
+        if (this.nodes.length === 0) {
+            return null;
+        }
+        if (this.nodes.length === 1) {
+            return this.nodes.pop();
+        }
+        const topValue = this.nodes[0];
+        this.nodes[0] = this.nodes.pop();
+        this.sinkDown(0);
+        return topValue;
     }
-}
-export class Heap {
     /**
-     * The function is a constructor for a class that initializes a priority callback function based on the
-     * options provided.
-     * @param [options] - An optional object that contains configuration options for the Heap.
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
      */
-    constructor(options) {
-        if (options) {
-            const { priorityExtractor } = options;
-            if (priorityExtractor !== undefined && typeof priorityExtractor !== 'function') {
-                throw new Error('.constructor expects a valid priority function');
+    bubbleUp(index) {
+        const element = this.nodes[index];
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            const parent = this.nodes[parentIndex];
+            if (this.comparator(element, parent) < 0) {
+                this.nodes[index] = parent;
+                this.nodes[parentIndex] = element;
+                index = parentIndex;
             }
-            this._priorityExtractor = priorityExtractor || (el => +el);
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     */
+    sinkDown(index) {
+        const leftChildIndex = 2 * index + 1;
+        const rightChildIndex = 2 * index + 2;
+        const length = this.nodes.length;
+        let targetIndex = index;
+        if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
+            targetIndex = leftChildIndex;
+        }
+        if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
+            targetIndex = rightChildIndex;
         }
-        else {
-            this._priorityExtractor = el => +el;
+        if (targetIndex !== index) {
+            const temp = this.nodes[index];
+            this.nodes[index] = this.nodes[targetIndex];
+            this.nodes[targetIndex] = temp;
+            this.sinkDown(targetIndex);
         }
     }
-    get pq() {
-        return this._pq;
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    fix() {
+        for (let i = Math.floor(this.size / 2); i >= 0; i--)
+            this.sinkDown(i);
     }
-    get priorityExtractor() {
-        return this._priorityExtractor;
+    /**
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or null if the heap is empty.
+     */
+    peek() {
+        if (this.nodes.length === 0) {
+            return null;
+        }
+        return this.nodes[0];
     }
     /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
+     * Get the size (number of elements) of the heap.
      */
     get size() {
-        return this._pq.size;
+        return this.nodes.length;
     }
     /**
-     * The function checks if a priority queue is empty.
-     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or null if the heap is empty.
+     */
+    get leaf() {
+        var _a;
+        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Check if the heap is empty.
+     * @returns True if the heap is empty, otherwise false.
      */
     isEmpty() {
-        return this._pq.size < 1;
+        return this.size === 0;
     }
     /**
-     * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<V>` object or `null`.Returns an val with the highest priority in the queue
+     * Reset the nodes of the heap. Make the nodes empty.
      */
-    peek(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const peeked = this._pq.peek();
-        return isItem ? peeked : peeked === null || peeked === void 0 ? void 0 : peeked.val;
+    clear() {
+        this.nodes = [];
     }
     /**
-     * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<V>` object or `null`.Returns an val with the lowest priority in the queue
+     * Clear and add nodes of the heap
+     * @param nodes
      */
-    peekLast(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const leafItem = this._pq.leaf();
-        return isItem ? leafItem : leafItem === null || leafItem === void 0 ? void 0 : leafItem.val;
+    refill(nodes) {
+        this.nodes = nodes;
+        this.fix();
     }
     /**
-     * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {V} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
-     * type.
-     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
-     * the value of `val`. If the `val` parameter is not a number, then the
-     * @returns The `add` method returns the instance of the `Heap` class.
-     * @throws {Error} if priority is not a valid number
+     * Use a comparison function to check whether a binary heap contains a specific element.
+     * @param value - the element to check.
+     * @returns Returns true if the specified element is contained; otherwise, returns false.
      */
-    add(priority, val) {
-        val = val === undefined ? priority : val;
-        this._pq.add(new HeapItem(priority, val));
-        return this;
+    has(value) {
+        return this.nodes.includes(value);
     }
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
-     * @returns either a HeapItem<V> object or null.
+     * Depth-first search (DFS) method, different traversal orders can be selected。
+     * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @returns An array containing elements traversed in the specified order.
      */
-    poll(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const top = this._pq.poll();
-        if (!top) {
-            return null;
-        }
-        return isItem ? top : top.val;
+    dfs(order) {
+        const result = [];
+        // Auxiliary recursive function, traverses the binary heap according to the traversal order
+        const dfsHelper = (index) => {
+            if (index < this.size) {
+                if (order === 'in') {
+                    dfsHelper(2 * index + 1);
+                    result.push(this.nodes[index]);
+                    dfsHelper(2 * index + 2);
+                }
+                else if (order === 'pre') {
+                    result.push(this.nodes[index]);
+                    dfsHelper(2 * index + 1);
+                    dfsHelper(2 * index + 2);
+                }
+                else if (order === 'post') {
+                    dfsHelper(2 * index + 1);
+                    dfsHelper(2 * index + 2);
+                    result.push(this.nodes[index]);
+                }
+            }
+        };
+        dfsHelper(0); // Traverse starting from the root node
+        return result;
     }
     /**
-     * The function checks if a given node or value exists in the priority queue.
-     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
-     * @returns a boolean value.
+     * Convert the heap to an array.
+     * @returns An array containing the elements of the heap.
      */
-    has(node) {
-        if (node instanceof HeapItem) {
-            return this.pq.getNodes().includes(node);
-        }
-        else {
-            return (this.pq.getNodes().findIndex(item => {
-                return item.val === node;
-            }) !== -1);
-        }
+    toArray() {
+        return [...this.nodes];
+    }
+    getNodes() {
+        return this.nodes;
     }
     /**
-     * The `toArray` function returns an array of `HeapItem<V>` objects.
-     * @returns An array of HeapItem<V> objects.Returns a sorted list of vals
+     * Clone the heap, creating a new heap with the same elements.
+     * @returns A new Heap instance containing the same elements.
      */
-    toArray(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const itemArray = this._pq.toArray();
-        return isItem ? itemArray : itemArray.map(item => item.val);
+    clone() {
+        const clonedHeap = new Heap(this.comparator);
+        clonedHeap.nodes = [...this.nodes];
+        return clonedHeap;
     }
     /**
-     * The function sorts the elements in the priority queue and returns either the sorted items or their values depending
-     * on the value of the isItem parameter.
-     * @param {boolean} [isItem] - The `isItem` parameter is a boolean flag that indicates whether the sorted result should
-     * be an array of `HeapItem<V>` objects or an array of the values (`V`) of those objects. If `isItem` is `true`, the
-     * sorted result will be an array of `HeapItem
-     * @returns an array of either `HeapItem<V>`, `null`, `V`, or `undefined` values.
+     * Sort the elements in the heap and return them as an array.
+     * @returns An array containing the elements sorted in ascending order.
      */
-    sort(isItem) {
-        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
-        const sorted = this._pq.sort();
-        return isItem ? sorted : sorted.map(item => item.val);
+    sort() {
+        const visitedNode = [];
+        const cloned = this.clone();
+        while (cloned.size !== 0) {
+            const top = cloned.poll();
+            if (top)
+                visitedNode.push(top);
+        }
+        return visitedNode;
     }
     /**
-     * The clear function clears the priority queue.
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @param nodes
+     * @param comparator - Comparison function.
+     * @returns A new Heap instance.
      */
-    clear() {
-        this._pq.clear();
+    static heapify(nodes, comparator) {
+        const binaryHeap = new Heap(comparator);
+        binaryHeap.nodes = [...nodes];
+        binaryHeap.fix(); // Fix heap properties
+        return binaryHeap;
     }
 }

package/lib/data-structures/heap/max-heap.d.ts

@@ -1,23 +1,12 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { Heap, HeapItem } from './heap';
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-/**
- * @class MaxHeap
- * @extends Heap
- */
-export declare class MaxHeap<V = any> extends Heap<V> {
-    protected _pq: PriorityQueue<HeapItem<V>>;
-    /**
-     * The constructor initializes a PriorityQueue with a custom comparator function.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<V>);
+import { Heap } from './heap';
+import type { CompareFunction } from '../../types';
+export declare class MaxHeap<E = any> extends Heap<E> {
+    constructor(comparator?: CompareFunction<E>);
 }

package/lib/data-structures/heap/max-heap.js

@@ -1,26 +1,20 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import { Heap } from './heap';
-import { PriorityQueue } from '../priority-queue';
-/**
- * @class MaxHeap
- * @extends Heap
- */
 export class MaxHeap extends Heap {
-    /**
-     * The constructor initializes a PriorityQueue with a custom comparator function.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options) {
-        super(options);
-        this._pq = new PriorityQueue({
-            comparator: (a, b) => b.priority - a.priority
-        });
+    constructor(comparator = (a, b) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+            throw new Error('The a, b params of compare function must be number');
+        }
+        else {
+            return b - a;
+        }
+    }) {
+        super(comparator);
     }
 }

package/lib/data-structures/heap/min-heap.d.ts

@@ -1,24 +1,12 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { Heap, HeapItem } from './heap';
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-/**
- * @class MinHeap
- * @extends Heap
- */
-export declare class MinHeap<V = any> extends Heap<V> {
-    protected _pq: PriorityQueue<HeapItem<V>>;
-    /**
-     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
-     * objects.
-     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
-     */
-    constructor(options?: HeapOptions<V>);
+import { Heap } from './heap';
+import type { CompareFunction } from '../../types';
+export declare class MinHeap<E = any> extends Heap<E> {
+    constructor(comparator?: CompareFunction<E>);
 }