min-heap-typed 1.42.8 → 1.42.9

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

@@ -33,21 +33,49 @@ export declare class Heap<E = any> {
         comparator: Comparator<E>;
     }): Heap<E>;
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
     add(element: E): Heap<E>;
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
     push(element: E): Heap<E>;
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * 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;
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -67,49 +95,116 @@ export declare class Heap<E = any> {
      */
     clear(): void;
     /**
+     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Space Complexity: O(n)
+     *
      * Clear and add nodes of the heap
      * @param nodes
      */
     refill(nodes: E[]): void;
     /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * 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.
      */
     has(element: E): boolean;
     /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(h), where h is the height of the heap.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(h), where h is the height of the heap.
+     *
      * 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[];
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * Convert the heap to an array.
      * @returns An array containing the elements of the heap.
      */
     toArray(): E[];
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     getNodes(): E[];
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
      */
     clone(): Heap<E>;
     /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
      */
     sort(): E[];
     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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): void;
     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
      */
     protected sinkDown(index: number): void;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * Fix the entire heap to maintain heap properties.
      */
     protected fix(): void;
@@ -140,28 +235,52 @@ export declare class FibonacciHeap<E> {
      */
     clear(): void;
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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>;
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Insert an element into the heap and maintain the heap properties.
      * @param element
      * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
      */
     push(element: E): FibonacciHeap<E>;
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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;
     /**
-     * O(1) time operation.
+     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes 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
@@ -169,26 +288,45 @@ export declare class FibonacciHeap<E> {
      */
     consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
     /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * @param parent
      * @param node
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * 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.
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * 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.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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
      */
@@ -207,19 +345,38 @@ export declare class FibonacciHeap<E> {
      */
     protected createNode(element: E): FibonacciHeapNode<E>;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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;
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *.
      * 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.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @param y
      * @param x
@@ -227,7 +384,13 @@ export declare class FibonacciHeap<E> {
      */
     protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(n)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */

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

@@ -45,6 +45,13 @@ class Heap {
         return new Heap(options);
     }
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
@@ -52,6 +59,13 @@ class Heap {
         return this.push(element);
     }
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
@@ -61,6 +75,13 @@ class Heap {
         return this;
     }
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -77,6 +98,13 @@ class Heap {
         return topValue;
     }
     /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -107,6 +135,13 @@ class Heap {
         this._nodes = [];
     }
     /**
+     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Space Complexity: O(n)
+     *
      * Clear and add nodes of the heap
      * @param nodes
      */
@@ -115,6 +150,13 @@ class Heap {
         this.fix();
     }
     /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * 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.
@@ -123,6 +165,13 @@ class Heap {
         return this.nodes.includes(element);
     }
     /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(h), where h is the height of the heap.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Space Complexity: O(h), where h is the height of the heap.
+     *
      * 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.
@@ -153,16 +202,34 @@ class Heap {
         return result;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * Convert the heap to an array.
      * @returns An array containing the elements of the heap.
      */
     toArray() {
         return [...this.nodes];
     }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
     getNodes() {
         return this.nodes;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
      */
@@ -172,6 +239,13 @@ class Heap {
         return clonedHeap;
     }
     /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * 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.
      */
@@ -186,6 +260,13 @@ class Heap {
         return visitedNode;
     }
     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
      */
@@ -205,6 +286,13 @@ class Heap {
         }
     }
     /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
      */
@@ -227,6 +315,13 @@ class Heap {
         }
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
      * Fix the entire heap to maintain heap properties.
      */
     fix() {
@@ -274,7 +369,13 @@ class FibonacciHeap {
         this._size = 0;
     }
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
@@ -283,7 +384,13 @@ class FibonacciHeap {
         return this.push(element);
     }
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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.
@@ -300,7 +407,13 @@ class FibonacciHeap {
         return this;
     }
     /**
-     * O(1) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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
@@ -309,7 +422,13 @@ class FibonacciHeap {
         return this.min ? this.min.element : undefined;
     }
     /**
-     * O(1) time operation.
+     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of nodes 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
@@ -334,8 +453,9 @@ class FibonacciHeap {
         return nodes;
     }
     /**
-     * O(log n) time operation.
-     * Remove and return the top element (smallest or largest element) from the heap.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * @param parent
      * @param node
      */
@@ -351,7 +471,13 @@ class FibonacciHeap {
         }
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -359,7 +485,13 @@ class FibonacciHeap {
         return this.pop();
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
@@ -387,7 +519,13 @@ class FibonacciHeap {
         return z.element;
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * 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
      */
@@ -437,6 +575,13 @@ class FibonacciHeap {
         return new FibonacciHeapNode(element);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Merge the given node with the root list.
      * @param node - The node to be merged.
      */
@@ -452,7 +597,13 @@ class FibonacciHeap {
         }
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *.
      * Remove and return the top element (smallest or largest element) from the heap.
      * @param node - The node to be removed.
      * @protected
@@ -466,7 +617,13 @@ class FibonacciHeap {
             node.right.left = node.left;
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @param y
      * @param x
@@ -481,7 +638,13 @@ class FibonacciHeap {
         y.parent = x;
     }
     /**
-     * O(log n) time operation.
+     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Space Complexity: O(n)
+     *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */