min-heap-typed 1.49.6 → 1.49.7

package/dist/types/data-structures/matrix/matrix.d.ts

@@ -1 +1,7 @@
-export {};
+export type MatrixOptions = {
+    rows?: number;
+    cols?: number;
+    addFn?: (a: number, b: number) => any;
+    subtractFn?: (a: number, b: number) => any;
+    multiplyFn?: (a: number, b: number) => any;
+};

package/dist/types/data-structures/queue/deque.d.ts

@@ -1 +1,3 @@
-export {};
+export type DequeOptions = {
+    bucketSize?: number;
+};

package/dist/types/data-structures/trie/trie.d.ts

@@ -1 +1,3 @@
-export {};
+export type TrieOptions = {
+    caseSensitive?: boolean;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.49.6",
+  "version": "1.49.7",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.49.5"
+    "data-structure-typed": "^1.49.7"
   }
 }

package/src/data-structures/binary-tree/avl-tree.ts

@@ -48,17 +48,17 @@ export class AVLTree<
   extends BST<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
   /**
-   * The constructor function initializes an AVLTree object with optional nodes and options.
-   * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+   * The constructor function initializes an AVLTree object with optional keysOrNodesOrEntries and options.
+   * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
    * objects. It represents a collection of nodes that will be added to the AVL tree during
    * initialization.
    * @param [options] - The `options` parameter is an optional object that allows you to customize the
    * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
    * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
    */
-  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<AVLTreeOptions<K>>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: AVLTreeOptions<K>) {
     super([], options);
-    if (nodes) super.addMany(nodes);
+    if (keysOrNodesOrEntries) super.addMany(keysOrNodesOrEntries);
   }
 
   /**

package/src/data-structures/binary-tree/binary-tree.ts

@@ -111,29 +111,25 @@ export class BinaryTree<
   iterationType = IterationType.ITERATIVE;
 
   /**
-   * The constructor function initializes a binary tree object with optional nodes and options.
-   * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+   * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
+   * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
    * nodes to be added to the binary tree.
    * @param [options] - The `options` parameter is an optional object that can contain additional
    * configuration options for the binary tree. In this case, it is of type
    * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
    * required.
    */
-  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<BinaryTreeOptions<K>>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: BinaryTreeOptions<K>) {
     super();
     if (options) {
       const { iterationType, extractor } = options;
-      if (iterationType) {
-        this.iterationType = iterationType;
-      }
-      if (extractor) {
-        this._extractor = extractor;
-      }
+      if (iterationType) this.iterationType = iterationType;
+      if (extractor) this._extractor = extractor;
     }
 
     this._size = 0;
 
-    if (nodes) this.addMany(nodes);
+    if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
   protected _extractor = (key: K) => Number(key);

package/src/data-structures/binary-tree/bst.ts

@@ -92,25 +92,23 @@ export class BST<
   implements IBinaryTree<K, V, N, TREE> {
   /**
    * This is the constructor function for a binary search tree class in TypeScript, which initializes
-   * the tree with optional nodes and options.
-   * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
+   * the tree with optional keysOrNodesOrEntries and options.
+   * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
    * binary search tree.
    * @param [options] - The `options` parameter is an optional object that can contain additional
    * configuration options for the binary search tree. It can have the following properties:
    */
-  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<BSTOptions<K>>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: BSTOptions<K>) {
     super([], options);
 
     if (options) {
       const { variant } = options;
-      if (variant) {
-        this._variant = variant;
-      }
+      if (variant) this._variant = variant;
     }
 
     this._root = undefined;
 
-    if (nodes) this.addMany(nodes);
+    if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
   protected override _root?: N;

package/src/data-structures/binary-tree/rb-tree.ts

@@ -53,7 +53,7 @@ export class RedBlackTree<
   /**
    * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
    * initializes the tree with optional nodes and options.
-   * @param [nodes] - The `nodes` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
+   * @param [keysOrNodesOrEntries] - The `keysOrNodesOrEntries` parameter is an optional iterable of `KeyOrNodeOrEntry<K, V, N>`
    * objects. It represents the initial nodes that will be added to the RBTree during its
    * construction. If this parameter is provided, the `addMany` method is called to add all the
    * nodes to the
@@ -61,11 +61,11 @@ export class RedBlackTree<
    * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
    * only a subset of the properties defined in the `RBTreeOptions` interface.
    */
-  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<RBTreeOptions<K>>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: RBTreeOptions<K>) {
     super([], options);
 
     this._root = this.Sentinel;
-    if (nodes) super.addMany(nodes);
+    if (keysOrNodesOrEntries) super.addMany(keysOrNodesOrEntries);
   }
 
   protected _root: N;

package/src/data-structures/binary-tree/tree-multimap.ts

@@ -52,9 +52,9 @@ export class TreeMultimap<
 >
   extends AVLTree<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
-  constructor(nodes?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: TreeMultimapOptions<K>) {
     super([], options);
-    if (nodes) this.addMany(nodes);
+    if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
   private _count = 0;

package/src/data-structures/hash/hash-map.ts

@@ -5,34 +5,35 @@
  * @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';
 import { isWeakKey, rangeCheck } from '../../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.
  */
 export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
 
   /**
-   * 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>) {
     super();
     if (options) {
       const { hashFn } = options;
@@ -40,8 +41,8 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
         this._hashFn = hashFn;
       }
     }
-    if (elements) {
-      this.setMany(elements);
+    if (entries) {
+      this.setMany(entries);
     }
   }
 
@@ -88,12 +89,12 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 
   /**
    * 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[] {
     const results: boolean[] = [];
-    for (const [key, value] of elements) results.push(this.set(key, value));
+    for (const [key, value] of entries) results.push(this.set(key, value));
     return results;
   }
 
@@ -214,10 +215,6 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return filteredMap;
   }
 
-  print(): void {
-    console.log([...this.entries()]);
-  }
-
   put(key: K, value: V): boolean {
     return this.set(key, value);
   }
@@ -261,8 +258,8 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 }
 
 /**
- * 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 class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
@@ -271,25 +268,20 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   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> = {
-      hashFn: (key: K) => String(key),
-      objHashFn: (key: K) => <object>key
-    }
-  ) {
+
+  constructor(entries?: Iterable<[K, V]>, options?: LinkedHashMapOptions<K>) {
     super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     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]);
       }
     }
@@ -547,7 +539,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * 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 {
     this._noObjMap = {};
@@ -564,11 +556,6 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return cloned;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -596,11 +583,6 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return filteredMap;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -629,12 +611,26 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return mappedMap;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
   put(key: K, value: V): boolean {
     return this.set(key, value);
   }
 
   /**
-   * 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 = (key: K) => String(key);
+
+  protected _objHashFn: (key: K) => object = (key: K) => <object>key;
+
+  /**
+   * 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/src/data-structures/hash/index.ts

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

package/src/data-structures/heap/heap.ts

@@ -21,23 +21,12 @@ 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 class Heap<E = any> extends IterableElementBase<E> {
-  options: HeapOptions<E>;
-
-  constructor(elements?: Iterable<E>, options?: HeapOptions<E>) {
+  constructor(elements: Iterable<E> = [], options?: HeapOptions<E>) {
     super();
-    const defaultComparator = (a: E, b: E) => {
-      if (!(typeof a === 'number' && typeof b === 'number')) {
-        throw new Error('The a, b params of compare function must be number');
-      } else {
-        return a - b;
-      }
-    };
+
     if (options) {
-      this.options = options;
-    } else {
-      this.options = {
-        comparator: defaultComparator
-      };
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
     }
 
     if (elements) {
@@ -48,6 +37,18 @@ export class Heap<E = any> extends IterableElementBase<E> {
     }
   }
 
+  protected _comparator = (a: E, b: E) => {
+    if (!(typeof a === 'number' && typeof b === 'number')) {
+      throw new Error('The a, b params of compare function must be number');
+    } else {
+      return a - b;
+    }
+  };
+
+  get comparator() {
+    return this._comparator;
+  }
+
   protected _elements: E[] = [];
 
   get elements(): E[] {
@@ -278,7 +279,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * @returns A new Heap instance containing the same elements.
    */
   clone(): Heap<E> {
-    const clonedHeap = new Heap<E>([], this.options);
+    const clonedHeap = new Heap<E>([], { comparator: this.comparator });
     clonedHeap._elements = [...this.elements];
     return clonedHeap;
   }
@@ -413,7 +414,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
     while (index > 0) {
       const parent = (index - 1) >> 1;
       const parentItem = this.elements[parent];
-      if (this.options.comparator(parentItem, element) <= 0) break;
+      if (this.comparator(parentItem, element) <= 0) break;
       this.elements[index] = parentItem;
       index = parent;
     }
@@ -435,11 +436,11 @@ export class Heap<E = any> extends IterableElementBase<E> {
       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) break;
+      if (this.comparator(minItem, element) >= 0) break;
       this.elements[index] = minItem;
       index = left;
     }

package/src/data-structures/heap/max-heap.ts

@@ -20,7 +20,7 @@ import { Heap } from './heap';
  */
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

package/src/data-structures/heap/min-heap.ts

@@ -20,7 +20,7 @@ import { Heap } from './heap';
  */
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: HeapOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -35,7 +35,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and size.
    */
-  constructor(elements?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
     this._head = undefined;
     this._tail = undefined;

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -27,11 +27,8 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
-  constructor(elements?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._head = undefined;
-    this._tail = undefined;
-    this._size = 0;
     if (elements) {
       for (const el of elements) this.push(el);
     }
@@ -49,7 +46,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return this._tail;
   }
 
-  protected _size: number;
+  protected _size: number = 0;
 
   get size(): number {
     return this._size;

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { SkipLinkedListOptions } from '../../types';
 
 export class SkipListNode<K, V> {
   key: K;
@@ -19,39 +20,37 @@ export class SkipListNode<K, V> {
 }
 
 export 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 = 16, probability = 0.5) {
-    this._head = new SkipListNode<K, V>(undefined as any, undefined as any, maxLevel);
-    this._level = 0;
-    this._maxLevel = maxLevel;
-    this._probability = probability;
+  constructor(elements: Iterable<[K, V]> = [], options?: SkipLinkedListOptions) {
+    if (options) {
+      const { maxLevel, probability } = options;
+      if (typeof maxLevel === 'number') this._maxLevel = maxLevel;
+      if (typeof probability === 'number') this._probability = probability;
+    }
+
+    if (elements) {
+      for (const [key, value] of elements) this.add(key, value);
+    }
   }
 
-  protected _head: SkipListNode<K, V>;
+  protected _head: SkipListNode<K, V> = new SkipListNode<K, V>(undefined as any, undefined as any, this.maxLevel);
 
   get head(): SkipListNode<K, V> {
     return this._head;
   }
 
-  protected _level: number;
+  protected _level: number = 0;
 
   get level(): number {
     return this._level;
   }
 
-  protected _maxLevel: number;
+  protected _maxLevel: number = 16;
 
   get maxLevel(): number {
     return this._maxLevel;
   }
 
-  protected _probability: number;
+  protected _probability: number = 0.5;
 
   get probability(): number {
     return this._probability;

package/src/data-structures/matrix/matrix.ts

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { MatrixOptions } from '../../types';
 
 export class Matrix {
   /**
@@ -14,16 +15,7 @@ export class Matrix {
    * @param [options] - The `options` parameter is an optional object that can contain the following
    * properties:
    */
-  constructor(
-    data: number[][],
-    options?: {
-      rows?: number;
-      cols?: number;
-      addFn?: (a: number, b: number) => any;
-      subtractFn?: (a: number, b: number) => any;
-      multiplyFn?: (a: number, b: number) => any;
-    }
-  ) {
+  constructor(data: number[][], options?: MatrixOptions) {
     if (options) {
       const { rows, cols, addFn, subtractFn, multiplyFn } = options;
       if (typeof rows === 'number' && rows > 0) this._rows = rows;

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -10,7 +10,7 @@ import { PriorityQueue } from './priority-queue';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -10,7 +10,7 @@ import { PriorityQueue } from './priority-queue';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    elements?: Iterable<E>,
+    elements: Iterable<E> = [],
     options: PriorityQueueOptions<E> = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {

package/src/data-structures/priority-queue/priority-queue.ts

@@ -17,7 +17,7 @@ import { Heap } from '../heap';
  * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
  */
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>) {
+  constructor(elements: Iterable<E> = [], options?: PriorityQueueOptions<E>) {
     super(elements, options);
   }
 }