priority-queue-typed 1.49.5 → 1.49.7

package/dist/data-structures/binary-tree/tree-multimap.js

@@ -24,11 +24,11 @@ exports.TreeMultimapNode = TreeMultimapNode;
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 class TreeMultimap extends avl_tree_1.AVLTree {
-    constructor(elements, options) {
+    constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
         this._count = 0;
-        if (elements)
-            this.addMany(elements);
+        if (keysOrNodesOrEntries)
+            this.addMany(keysOrNodesOrEntries);
     }
     // TODO the _count is not accurate after nodes count modified
     get count() {
@@ -52,26 +52,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
-     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
-     * class.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof TreeMultimapNode;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`, which means it
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
@@ -80,16 +62,16 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * times the value should be added to the node. If not provided, it defaults to 1.
      * @returns a node of type `N` or `undefined`.
      */
-    exemplarToNode(exemplar, value, count = 1) {
+    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
-        if (exemplar === undefined || exemplar === null) {
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined || key === null) {
                 return;
             }
@@ -97,8 +79,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value, count);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
             return;
@@ -106,12 +88,31 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return node;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+     * class.
      */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof TreeMultimapNode);
+    }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the add method of a binary tree node and adds a new node to the tree.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
@@ -128,21 +129,22 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     add(keyOrNodeOrEntry, value, count = 1) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
-            return;
+            return false;
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
         const inserted = super.add(newNode);
         if (inserted) {
             this._count += orgNodeCount;
         }
-        return inserted;
+        return true;
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
      * structure.
@@ -154,12 +156,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
      */
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(n)
      *
      * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
      * tree using either a recursive or iterative approach.
@@ -205,12 +208,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
+     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(k log n)
+     * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
      * account the count of the node and balancing the tree if necessary.
@@ -286,10 +290,13 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return deletedResult;
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear() {

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

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import type { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem, LinkedHashMapOptions } 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.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries 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.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
 export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     protected _store: {
@@ -19,16 +19,14 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     };
     protected _objMap: Map<object, V>;
     /**
-     * The constructor function initializes a new instance of a class with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements?: Iterable<[K, V]>, options?: {
-        hashFn: (key: K) => string;
-    });
+    constructor(entries?: Iterable<[K, V]>, options?: HashMapOptions<K>);
     protected _size: number;
     get size(): number;
     isEmpty(): boolean;
@@ -45,10 +43,10 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     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.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements: Iterable<[K, V]>): boolean[];
+    setMany(entries: 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.
@@ -113,7 +111,6 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      * from the original `HashMap` that pass the provided `predicate` function.
      */
     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
@@ -125,8 +122,8 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     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.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries 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 entries 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> {
@@ -135,9 +132,7 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
     protected _head: HashMapLinkedNode<K, V | undefined>;
     protected _tail: HashMapLinkedNode<K, V | undefined>;
     protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
-    protected _hashFn: (key: K) => string;
-    protected _objHashFn: (key: K) => object;
-    constructor(elements?: Iterable<[K, V]>, options?: HashMapOptions<K>);
+    constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>);
     protected _size: number;
     get size(): number;
     /**
@@ -242,14 +237,10 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear(): void;
     clone(): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -266,10 +257,6 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * `LinkedHashMap` object that satisfy the given predicate function.
      */
     filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -288,9 +275,19 @@ export declare class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K
      * function.
      */
     map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key: K, value: V): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    protected _hashFn: (key: K) => string;
+    protected _objHashFn: (key: K) => object;
+    /**
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

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

@@ -5,20 +5,20 @@ 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.
+ * 2. Fast Lookup: It's used when you need to quickly find, insert, or delete entries 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.
+ * 4. Unordered Collection: HashMap does not guarantee the order of entries, 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.
-     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * The constructor function initializes a new instance of a class with optional entries and options.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
      * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
      * key-value pairs.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the constructor. In this case, it has one property:
      */
-    constructor(elements = [], options) {
+    constructor(entries = [], options) {
         super();
         this._store = {};
         this._objMap = new Map();
@@ -30,8 +30,8 @@ class HashMap extends base_1.IterableEntryBase {
                 this._hashFn = hashFn;
             }
         }
-        if (elements) {
-            this.setMany(elements);
+        if (entries) {
+            this.setMany(entries);
         }
     }
     get size() {
@@ -72,12 +72,12 @@ class HashMap extends base_1.IterableEntryBase {
     }
     /**
      * 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.
+     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two entries: the key and the value.
      */
-    setMany(elements) {
+    setMany(entries) {
         const results = [];
-        for (const [key, value] of elements)
+        for (const [key, value] of entries)
             results.push(this.set(key, value));
         return results;
     }
@@ -194,9 +194,6 @@ class HashMap extends base_1.IterableEntryBase {
         }
         return filteredMap;
     }
-    print() {
-        console.log([...this.entries()]);
-    }
     put(key, value) {
         return this.set(key, value);
     }
@@ -236,26 +233,33 @@ 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.
+ * 1. Maintaining the Order of Element Insertion: Unlike HashMap, LinkedHashMap maintains the order in which entries are inserted. Therefore, when you traverse it, entries 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 entries 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),
-        objHashFn: (key) => key
-    }) {
+    constructor(entries, options) {
         super();
         this._noObjMap = {};
         this._objMap = new WeakMap();
         this._size = 0;
+        /**
+         * Time Complexity: O(n)
+         * Space Complexity: O(n)
+         */
+        this._hashFn = (key) => String(key);
+        this._objHashFn = (key) => key;
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        const { hashFn, objHashFn } = options;
-        this._hashFn = hashFn;
-        this._objHashFn = objHashFn;
-        if (elements) {
-            for (const el of elements) {
+        if (options) {
+            const { hashFn, objHashFn } = options;
+            if (hashFn)
+                this._hashFn = hashFn;
+            if (objHashFn)
+                this._objHashFn = objHashFn;
+        }
+        if (entries) {
+            for (const el of entries) {
                 this.set(el[0], el[1]);
             }
         }
@@ -495,7 +499,7 @@ class LinkedHashMap extends base_1.IterableEntryBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function clears all the elements in a data structure and resets its properties.
+     * The `clear` function clears all the entries in a data structure and resets its properties.
      */
     clear() {
         this._noObjMap = {};
@@ -510,10 +514,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return cloned;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -540,10 +540,6 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return filteredMap;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -571,11 +567,15 @@ class LinkedHashMap extends base_1.IterableEntryBase {
         }
         return mappedMap;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
     put(key, value) {
         return this.set(key, value);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
+     * Time Complexity: O(n), where n is the number of entries in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.

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

@@ -1,2 +1 @@
-export * from './hash-table';
 export * from './hash-map';

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

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hash-table"), exports);
 __exportStar(require("./hash-map"), exports);

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

@@ -19,8 +19,9 @@ 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> {
-    options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
+    protected _comparator: (a: E, b: E) => number;
+    get comparator(): (a: E, b: E) => number;
     protected _elements: E[];
     get elements(): E[];
     /**

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

@@ -21,10 +21,9 @@ 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 {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
         super();
-        this._elements = [];
-        const defaultComparator = (a, b) => {
+        this._comparator = (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');
             }
@@ -32,13 +31,11 @@ class Heap extends base_1.IterableElementBase {
                 return a - b;
             }
         };
+        this._elements = [];
         if (options) {
-            this.options = options;
-        }
-        else {
-            this.options = {
-                comparator: defaultComparator
-            };
+            const { comparator } = options;
+            if (comparator)
+                this._comparator = comparator;
         }
         if (elements) {
             for (const el of elements) {
@@ -47,6 +44,9 @@ class Heap extends base_1.IterableElementBase {
             // this.fix();
         }
     }
+    get comparator() {
+        return this._comparator;
+    }
     get elements() {
         return this._elements;
     }
@@ -256,7 +256,7 @@ class Heap extends base_1.IterableElementBase {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-        const clonedHeap = new Heap([], this.options);
+        const clonedHeap = new Heap([], { comparator: this.comparator });
         clonedHeap._elements = [...this.elements];
         return clonedHeap;
     }
@@ -382,7 +382,7 @@ class Heap extends base_1.IterableElementBase {
         while (index > 0) {
             const parent = (index - 1) >> 1;
             const parentItem = this.elements[parent];
-            if (this.options.comparator(parentItem, element) <= 0)
+            if (this.comparator(parentItem, element) <= 0)
                 break;
             this.elements[index] = parentItem;
             index = parent;
@@ -404,11 +404,11 @@ class Heap extends base_1.IterableElementBase {
             let left = (index << 1) | 1;
             const right = left + 1;
             let minItem = this.elements[left];
-            if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
+            if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
                 left = right;
                 minItem = this.elements[right];
             }
-            if (this.options.comparator(minItem, element) >= 0)
+            if (this.comparator(minItem, element) >= 0)
                 break;
             this.elements[index] = minItem;
             index = left;

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

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 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 = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

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

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 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 = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -25,7 +25,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and size.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
         this._head = undefined;
         this._tail = undefined;

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -18,10 +18,8 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
-        this._head = undefined;
-        this._tail = undefined;
         this._size = 0;
         if (elements) {
             for (const el of elements)

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { SkipLinkedListOptions } from '../../types';
 export declare class SkipListNode<K, V> {
     key: K;
     value: V;
@@ -12,14 +13,7 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
-    /**
-     * The constructor initializes a SkipList with a specified maximum level and probability.
-     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
-     * the maximum number of levels that can be created in the skip list.
-     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-     * level in the skip list. It is used to determine the height of each node in the skip list.
-     */
-    constructor(maxLevel?: number, probability?: number);
+    constructor(elements?: Iterable<[K, V]>, options?: SkipLinkedListOptions);
     protected _head: SkipListNode<K, V>;
     get head(): SkipListNode<K, V>;
     protected _level: number;