graph-typed 1.49.0 → 1.49.2

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,8 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
-import { IterableEntryBase } from "../base";
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from '../base';
+/**
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
@@ -36,13 +42,13 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      * @param {V} value - The value parameter represents the value that you want to associate with the
      * key in the data structure.
      */
-    set(key: K, value: V): void;
+    set(key: K, value: V): boolean;
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
      * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
      * key-value pair is represented as an array with two elements: the key and the value.
      */
-    setMany(elements: Iterable<[K, V]>): void;
+    setMany(elements: Iterable<[K, V]>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.
@@ -108,6 +114,7 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V>;
     print(): void;
+    put(key: K, value: V): boolean;
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
@@ -117,6 +124,11 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
     protected _getNoObjKey(key: K): string;
 }
+/**
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
+ */
 export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
@@ -167,9 +179,9 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * value associated with the key being set in the data structure.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key: K, value?: V): number;
+    set(key: K, value?: V): boolean;
     has(key: K): boolean;
-    setMany(entries: Iterable<[K, V]>): void;
+    setMany(entries: Iterable<[K, V]>): boolean[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -195,7 +207,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
      * where `K` is the key and `V` is the value.
      */
-    getAt(index: number): [K, V];
+    getAt(index: number): V | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -216,7 +228,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * deleted in the linked list.
      * @returns The size of the list after deleting the element at the specified index.
      */
-    deleteAt(index: number): number;
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -276,7 +288,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * function.
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
-    print(): void;
+    put(key: K, value: V): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
@@ -294,5 +306,5 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * represents a node in a linked list. It contains a key-value pair and references to the previous
      * and next nodes in the list.
      */
-    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean;
 }

package/dist/data-structures/hash/hash-map.js

@@ -1,15 +1,14 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkedHashMap = exports.HashMap = void 0;
-const utils_1 = require("../../utils");
 const base_1 = require("../base");
+const utils_1 = require("../../utils");
+/**
+ * 1. Key-Value Pair Storage: HashMap stores key-value pairs. Each key maps to a value.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete elements based on a key.
+ * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
+ * 4. Unordered Collection: HashMap does not guarantee the order of elements, and the order may change over time.
+ */
 class HashMap extends base_1.IterableEntryBase {
     /**
      * The constructor function initializes a new instance of a class with optional elements and options.
@@ -69,6 +68,7 @@ class HashMap extends base_1.IterableEntryBase {
             }
             this._store[strKey] = { key, value };
         }
+        return true;
     }
     /**
      * The function "setMany" sets multiple key-value pairs in a map.
@@ -76,8 +76,10 @@ class HashMap extends base_1.IterableEntryBase {
      * key-value pair is represented as an array with two elements: the key and the value.
      */
     setMany(elements) {
+        const results = [];
         for (const [key, value] of elements)
-            this.set(key, value);
+            results.push(this.set(key, value));
+        return results;
     }
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
@@ -195,6 +197,9 @@ class HashMap extends base_1.IterableEntryBase {
     print() {
         console.log([...this.entries()]);
     }
+    put(key, value) {
+        return this.set(key, value);
+    }
     /**
      * The function returns an iterator that yields key-value pairs from both an object store and an
      * object map.
@@ -230,6 +235,11 @@ class HashMap extends base_1.IterableEntryBase {
     }
 }
 exports.HashMap = HashMap;
+/**
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which elements are inserted. Therefore, when you traverse it, elements will be returned in the order they were inserted into the map.
+ * 2. Based on Hash Table and Linked List: It combines the structures of a hash table and a linked list, using the hash table to ensure fast access, while maintaining the order of elements through the linked list.
+ * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
+ */
 class LinkedHashMap extends base_1.IterableEntryBase {
     constructor(elements, options = {
         hashFn: (key) => String(key),
@@ -353,7 +363,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             this._sentinel.prev = node;
             this._size++;
         }
-        return this._size;
+        return true;
     }
     has(key) {
         if ((0, utils_1.isWeakKey)(key)) {
@@ -366,10 +376,12 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
     }
     setMany(entries) {
+        const results = [];
         for (const entry of entries) {
             const [key, value] = entry;
-            this.set(key, value);
+            results.push(this.set(key, value));
         }
+        return results;
     }
     /**
      * Time Complexity: O(1)
@@ -413,7 +425,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         while (index--) {
             node = node.next;
         }
-        return [node.key, node.value];
+        return node.value;
     }
     /**
      * Time Complexity: O(1)
@@ -466,8 +478,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         while (index--) {
             node = node.next;
         }
-        this._deleteNode(node);
-        return this._size;
+        return this._deleteNode(node);
     }
     /**
      * Time Complexity: O(1)
@@ -560,8 +571,8 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return mappedMap;
     }
-    print() {
-        console.log([...this]);
+    put(key, value) {
+        return this.set(key, value);
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
@@ -597,6 +608,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
             this._tail = prev;
         }
         this._size -= 1;
+        return true;
     }
 }
 exports.LinkedHashMap = LinkedHashMap;

package/dist/data-structures/hash/hash-table.d.ts

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class HashTableNode<K, V> {
+import type { HashFunction } from '../../types';
+export declare class HashTableNode<K = any, V = any> {
     key: K;
     value: V;
     next: HashTableNode<K, V> | undefined;
     constructor(key: K, value: V);
 }
-import { HashFunction } from '../../types';
 export declare class HashTable<K = any, V = any> {
     protected static readonly DEFAULT_CAPACITY = 16;
     protected static readonly LOAD_FACTOR = 0.75;

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

@@ -4,9 +4,20 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { Comparator, DFSOrderPattern, ElementCallback } from '../../types';
-import { HeapOptions } from "../../types";
-import { IterableElementBase } from "../base";
+import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * 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.
+ * Min Heap: The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 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> {
     options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
@@ -41,19 +52,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * 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 elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements 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>;
+    add(element: E): boolean;
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
@@ -66,18 +65,6 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @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 elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements 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;
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -103,7 +90,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Clear and add elements of the heap
      * @param elements
      */
-    refill(elements: E[]): void;
+    refill(elements: E[]): boolean[];
     /**
      * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
@@ -192,7 +179,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      *
      * Fix the entire heap to maintain heap properties.
      */
-    fix(): void;
+    fix(): boolean[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -239,12 +226,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * original Heap.
      */
     map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    print(): void;
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -256,7 +238,7 @@ export declare class Heap<E = any> extends IterableElementBase<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;
+    protected _bubbleUp(index: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -265,7 +247,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param index - The index from which to start sinking.
      * @param halfLength
      */
-    protected _sinkDown(index: number, halfLength: number): void;
+    protected _sinkDown(index: number, halfLength: number): boolean;
 }
 export declare class FibonacciHeapNode<E> {
     element: E;

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

@@ -8,6 +8,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
 const base_1 = require("../base");
+/**
+ * 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.
+ * Min Heap: The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 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 {
     constructor(elements, options) {
         super();
@@ -30,7 +42,7 @@ class Heap extends base_1.IterableElementBase {
         }
         if (elements) {
             for (const el of elements) {
-                this.push(el);
+                this.add(el);
             }
             // this.fix();
         }
@@ -73,23 +85,8 @@ class Heap extends base_1.IterableElementBase {
      * @param element - The element to be inserted.
      */
     add(element) {
-        return this.push(element);
-    }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements 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) {
         this._elements.push(element);
-        this._bubbleUp(this.elements.length - 1);
-        return this;
+        return this._bubbleUp(this.elements.length - 1);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -113,20 +110,6 @@ class Heap extends base_1.IterableElementBase {
         }
         return value;
     }
-    /**
-     * Time Complexity: O(log n), where n is the number of elements in the heap.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n), where n is the number of elements 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() {
-        return this.poll();
-    }
     /**
      * Peek at the top element of the heap without removing it.
      * @returns The top element or undefined if the heap is empty.
@@ -160,7 +143,7 @@ class Heap extends base_1.IterableElementBase {
      */
     refill(elements) {
         this._elements = elements;
-        this.fix();
+        return this.fix();
     }
     /**
      * Time Complexity: O(n), where n is the number of elements in the heap.
@@ -197,7 +180,7 @@ class Heap extends base_1.IterableElementBase {
         if (index < 0)
             return false;
         if (index === 0) {
-            this.pop();
+            this.poll();
         }
         else if (index === this.elements.length - 1) {
             this.elements.pop();
@@ -309,8 +292,10 @@ class Heap extends base_1.IterableElementBase {
      * Fix the entire heap to maintain heap properties.
      */
     fix() {
+        const results = [];
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
-            this._sinkDown(i, this.elements.length >> 1);
+            results.push(this._sinkDown(i, this.elements.length >> 1));
+        return results;
     }
     /**
      * Time Complexity: O(n)
@@ -337,7 +322,7 @@ class Heap extends base_1.IterableElementBase {
         let index = 0;
         for (const current of this) {
             if (callback.call(thisArg, current, index, this)) {
-                filteredList.push(current);
+                filteredList.add(current);
             }
             index++;
         }
@@ -376,13 +361,6 @@ class Heap extends base_1.IterableElementBase {
         }
         return mappedHeap;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         for (const element of this.elements) {
             yield element;
@@ -410,6 +388,7 @@ class Heap extends base_1.IterableElementBase {
             index = parent;
         }
         this.elements[index] = element;
+        return true;
     }
     /**
      * Time Complexity: O(log n)
@@ -436,6 +415,7 @@ class Heap extends base_1.IterableElementBase {
             index = left;
         }
         this.elements[index] = element;
+        return true;
     }
 }
 exports.Heap = Heap;

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

@@ -5,8 +5,18 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
 import type { HeapOptions } from '../../types';
+import { Heap } from './heap';
+/**
+ * 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: The value of each parent node is greater than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 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 MaxHeap<E = any> extends Heap<E> {
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
 }

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

@@ -1,14 +1,17 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxHeap = void 0;
 const heap_1 = require("./heap");
+/**
+ * 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: The value of each parent node is greater than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ */
 class MaxHeap extends heap_1.Heap {
     constructor(elements, options = {
         comparator: (a, b) => {

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

@@ -5,8 +5,18 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
 import type { HeapOptions } from '../../types';
+import { Heap } from './heap';
+/**
+ * 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:  The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 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 MinHeap<E = any> extends Heap<E> {
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
 }

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

@@ -1,14 +1,17 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinHeap = void 0;
 const heap_1 = require("./heap");
+/**
+ * 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:  The value of each parent node is less than or equal to the value of its children.
+ * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
+ * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
+ * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
+ * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
+ * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
+ * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
+ */
 class MinHeap extends heap_1.Heap {
     constructor(elements, options = {
         comparator: (a, b) => {