min-heap-typed 1.40.0-rc → 1.41.0

package/dist/data-structures/hash/tree-set.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSet = void 0;
+class TreeSet {
+}
+exports.TreeSet = TreeSet;

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

@@ -0,0 +1,235 @@
+/**
+ * data-structure-typed
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+import type { Comparator, DFSOrderPattern } from '../../types';
+export declare class Heap<E = any> {
+    constructor(options: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
+    protected _nodes: E[];
+    get nodes(): E[];
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
+    /**
+     * Get the size (number of elements) of the heap.
+     */
+    get size(): number;
+    /**
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or undefined if the heap is empty.
+     */
+    get leaf(): E | undefined;
+    /**
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @returns A new Heap instance.
+     * @param options
+     */
+    static heapify<E>(options: {
+        nodes: E[];
+        comparator: Comparator<E>;
+    }): Heap<E>;
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element - The element to be inserted.
+     */
+    add(element: E): Heap<E>;
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element - The element to be inserted.
+     */
+    push(element: E): Heap<E>;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    poll(): E | undefined;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    peek(): E | undefined;
+    /**
+     * Check if the heap is empty.
+     * @returns True if the heap is empty, otherwise false.
+     */
+    isEmpty(): boolean;
+    /**
+     * 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 element - the element to check.
+     * @returns Returns true if the specified element is contained; otherwise, returns false.
+     */
+    has(element: E): boolean;
+    /**
+     * 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.
+     */
+    dfs(order: DFSOrderPattern): 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[];
+    /**
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
+     */
+    protected bubbleUp(index: number): void;
+    /**
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     */
+    protected sinkDown(index: number): void;
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
+}
+export declare class FibonacciHeapNode<E> {
+    element: E;
+    degree: number;
+    left?: FibonacciHeapNode<E>;
+    right?: FibonacciHeapNode<E>;
+    child?: FibonacciHeapNode<E>;
+    parent?: FibonacciHeapNode<E>;
+    marked: boolean;
+    constructor(element: E, degree?: number);
+}
+export declare class FibonacciHeap<E> {
+    constructor(comparator?: Comparator<E>);
+    protected _root?: FibonacciHeapNode<E>;
+    get root(): FibonacciHeapNode<E> | undefined;
+    protected _size: number;
+    get size(): number;
+    protected _min?: FibonacciHeapNode<E>;
+    get min(): FibonacciHeapNode<E> | undefined;
+    protected _comparator: Comparator<E>;
+    get comparator(): Comparator<E>;
+    /**
+     * Get the size (number of elements) of the heap.
+     * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
+     */
+    clear(): void;
+    /**
+     * O(1) time operation.
+     * 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>;
+    /**
+     * O(1) time operation.
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element
+     * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
+     */
+    push(element: E): FibonacciHeap<E>;
+    /**
+     * O(1) time operation.
+     * 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;
+    /**
+     * O(1) time operation.
+     * 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 nodes of the linked list.
+     */
+    consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param parent
+     * @param node
+     */
+    mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    poll(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
+     * @param heapToMerge
+     */
+    merge(heapToMerge: FibonacciHeap<E>): void;
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
+     * @protected
+     */
+    protected defaultComparator(a: E, b: E): number;
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    protected createNode(element: E): FibonacciHeapNode<E>;
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param node - The node to be removed.
+     * @protected
+     */
+    protected removeFromRoot(node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param y
+     * @param x
+     * @protected
+     */
+    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
+     */
+    protected consolidate(): void;
+}