min-heap-typed 1.50.1 → 1.50.3

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

@@ -19,10 +19,28 @@ import { IterableElementBase } from '../base';
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 export declare class Heap<E = any> extends IterableElementBase<E> {
+    /**
+     * 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>, options?: HeapOptions<E>);
     protected _comparator: (a: E, b: E) => number;
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
     get comparator(): (a: E, b: E) => number;
     protected _elements: E[];
+    /**
+     * The function returns an array of elements.
+     * @returns The elements array is being returned.
+     */
     get elements(): E[];
     /**
      * Get the size (number of elements) of the heap.
@@ -43,11 +61,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
         comparator: Comparator<E>;
     }): Heap<E>;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -55,11 +74,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     add(element: E): boolean;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -67,6 +87,13 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     poll(): E | undefined;
     /**
+     * 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.
      */
@@ -81,11 +108,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     clear(): void;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * Clear and add elements of the heap
@@ -93,11 +120,11 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     refill(elements: E[]): boolean[];
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -106,11 +133,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     has(element: E): boolean;
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
+     * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
      */
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -122,12 +150,13 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     delete(element: E): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     * where log n is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * 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).
@@ -171,12 +200,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      */
     sort(): E[];
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * Fix the entire heap to maintain heap properties.
      */
@@ -227,9 +256,12 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * original Heap.
      */
     map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
+    /**
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     protected _getIterator(): IterableIterator<E>;
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -240,6 +272,10 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index of the newly added element.
      */
     protected _bubbleUp(index: number): boolean;
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -258,17 +294,51 @@ export declare class FibonacciHeapNode<E> {
     child?: 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?: number);
 }
 export declare 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.
+     */
     constructor(comparator?: Comparator<E>);
     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 root(): FibonacciHeapNode<E> | undefined;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     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 min(): FibonacciHeapNode<E> | undefined;
     protected _comparator: Comparator<E>;
+    /**
+     * The function returns the comparator used for comparing elements.
+     * @returns The `_comparator` property of the object.
+     */
     get comparator(): Comparator<E>;
     /**
      * Get the size (number of elements) of the heap.
@@ -337,11 +407,11 @@ export declare class FibonacciHeap<E> {
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -349,11 +419,11 @@ export declare class FibonacciHeap<E> {
      */
     poll(): E | undefined;
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -425,11 +495,11 @@ export declare class FibonacciHeap<E> {
      */
     protected _link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.

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

@@ -21,6 +21,16 @@ const base_1 = require("../base");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class Heap extends base_1.IterableElementBase {
+    /**
+     * The constructor initializes a heap data structure with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable object that contains the initial
+     * elements to be added to the heap. It is an optional parameter and if not provided, the heap will
+     * be initialized as empty.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the heap. In this case, it is used to specify a custom comparator
+     * function for comparing elements in the heap. The comparator function is used to determine the
+     * order of elements in the heap.
+     */
     constructor(elements = [], options) {
         super();
         this._comparator = (a, b) => {
@@ -41,12 +51,19 @@ class Heap extends base_1.IterableElementBase {
             for (const el of elements) {
                 this.add(el);
             }
-            // this.fix();
         }
     }
+    /**
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
+     */
     get comparator() {
         return this._comparator;
     }
+    /**
+     * The function returns an array of elements.
+     * @returns The elements array is being returned.
+     */
     get elements() {
         return this._elements;
     }
@@ -74,11 +91,12 @@ class Heap extends base_1.IterableElementBase {
         return new Heap(elements, options);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -89,11 +107,12 @@ class Heap extends base_1.IterableElementBase {
         return this._bubbleUp(this.elements.length - 1);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
+     * where n is the number of elements in the heap.
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -111,6 +130,13 @@ class Heap extends base_1.IterableElementBase {
         return value;
     }
     /**
+     * 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.
      */
@@ -131,11 +157,11 @@ class Heap extends base_1.IterableElementBase {
         this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the elements array.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
      * Clear and add elements of the heap
@@ -146,11 +172,11 @@ class Heap extends base_1.IterableElementBase {
         return this.fix();
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -161,11 +187,12 @@ class Heap extends base_1.IterableElementBase {
         return this.elements.includes(element);
     }
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
+     * The worst-case  O(n) This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
      */
     /**
-     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Time Complexity:  O(n)
      * Space Complexity: O(1)
      *
      * The `delete` function removes an element from an array-like data structure, maintaining the order
@@ -193,12 +220,13 @@ class Heap extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     * where log n is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the heap.
-     * Space Complexity: O(h), where h is the height of the heap.
+     * 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).
@@ -282,12 +310,12 @@ class Heap extends base_1.IterableElementBase {
         return visitedNode;
     }
     /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * Fix the entire heap to maintain heap properties.
      */
@@ -361,13 +389,16 @@ class Heap extends base_1.IterableElementBase {
         }
         return mappedHeap;
     }
+    /**
+     * The function `_getIterator` returns an iterable iterator for the elements in the class.
+     */
     *_getIterator() {
         for (const element of this.elements) {
             yield element;
         }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -390,6 +421,10 @@ class Heap extends base_1.IterableElementBase {
         this.elements[index] = element;
         return true;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -419,6 +454,16 @@ class Heap extends base_1.IterableElementBase {
 }
 exports.Heap = Heap;
 class FibonacciHeapNode {
+    /**
+     * The constructor function initializes an object with an element and a degree, and sets the marked
+     * property to false.
+     * @param {E} element - The "element" parameter represents the value or data that will be stored in
+     * the node of a data structure. It can be any type of data, such as a number, string, object, or
+     * even another data structure.
+     * @param [degree=0] - The degree parameter represents the degree of the element in a data structure
+     * called a Fibonacci heap. The degree of a node is the number of children it has. By default, the
+     * degree is set to 0 when a new node is created.
+     */
     constructor(element, degree = 0) {
         this.element = element;
         this.degree = degree;
@@ -427,6 +472,13 @@ class FibonacciHeapNode {
 }
 exports.FibonacciHeapNode = FibonacciHeapNode;
 class FibonacciHeap {
+    /**
+     * The constructor function initializes a FibonacciHeap object with an optional comparator function.
+     * @param [comparator] - The `comparator` parameter is an optional argument that represents a
+     * function used to compare elements in the FibonacciHeap. If a comparator function is provided, it
+     * will be used to determine the order of elements in the heap. If no comparator function is
+     * provided, a default comparator function will be used.
+     */
     constructor(comparator) {
         this._size = 0;
         this.clear();
@@ -435,15 +487,32 @@ class FibonacciHeap {
             throw new Error('FibonacciHeap constructor: given comparator should be a function.');
         }
     }
+    /**
+     * The function returns the root node of a Fibonacci heap.
+     * @returns The method is returning either a FibonacciHeapNode object or undefined.
+     */
     get root() {
         return this._root;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
         return this._size;
     }
+    /**
+     * The function returns the minimum node in a Fibonacci heap.
+     * @returns The method is returning the minimum node of the Fibonacci heap, which is of type
+     * `FibonacciHeapNode<E>`. If there is no minimum node, it will return `undefined`.
+     */
     get min() {
         return this._min;
     }
+    /**
+     * The function returns the comparator used for comparing elements.
+     * @returns The `_comparator` property of the object.
+     */
     get comparator() {
         return this._comparator;
     }
@@ -559,11 +628,11 @@ class FibonacciHeap {
         }
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -573,11 +642,11 @@ class FibonacciHeap {
         return this.pop();
     }
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -726,11 +795,11 @@ class FibonacciHeap {
         y.parent = x;
     }
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of elements in the heap.
+     * Time Complexity: O(n log n)
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.