queue-typed 1.47.5 → 1.47.6

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey } from '../../types';
-import { CP, IterationType } from '../../types';
+import type { BSTNested, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, Comparator } from '../../types';
+import { CP, IterableEntriesOrKeys, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
@@ -66,21 +66,23 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   extends BinaryTree<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
 
-  override options: BSTOptions;
-
   /**
    * The constructor function initializes a binary search tree with an optional comparator function.
    * @param {BSTOptions} [options] - An optional object that contains additional configuration options
    * for the binary search tree.
    */
-  constructor(options?: BSTOptions) {
-    super(options);
+  constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<BSTOptions>) {
+    super([], options);
+
     if (options) {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options }
-    } else {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
+      const { comparator } = options;
+      if (comparator) {
+        this.comparator = comparator;
+      }
     }
+
     this._root = undefined;
+    if (elements) this.init(elements);
   }
 
   protected override _root?: N;
@@ -92,6 +94,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return this._root;
   }
 
+  comparator: Comparator<BTNKey> = (a, b) => a - b
+
   /**
    * The function creates a new binary search tree node with the given key and value.
    * @param {BTNKey} key - The key parameter is the key value that will be associated with
@@ -104,15 +108,13 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return new BSTNode<V, N>(key, value) as N;
   }
 
-  override createTree(options?: BSTOptions): TREE {
-    return new BST<V, N, TREE>({ ...this.options, ...options }) as TREE;
+  override createTree(options?: Partial<BSTOptions>): TREE {
+    return new BST<V, N, TREE>([], {
+      iterationType: this.iterationType,
+      comparator: this.comparator, ...options
+    }) as TREE;
   }
 
-  /**
-   * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
-   * Space Complexity: O(1) - Constant space is used.
-   */
-
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
    * Space Complexity: O(1) - Constant space is used.
@@ -193,8 +195,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-   * Space Complexity: O(n) - Additional space is required for the sorted array.
+   * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+   * Space Complexity: O(1) - Constant space is used.
    */
 
   /**
@@ -221,7 +223,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     keysOrNodes: (BTNKey | N | undefined)[],
     data?: (V | undefined)[],
     isBalanceAdd = true,
-    iterationType = this.options.iterationType
+    iterationType = this.iterationType
   ): (N | undefined)[] {
     // TODO this addMany function is inefficient, it should be optimized
     function hasNoUndefined(arr: (BTNKey | N | undefined)[]): arr is (BTNKey | N)[] {
@@ -297,8 +299,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * Time Complexity: O(log n) - Average case for a balanced tree.
-   * Space Complexity: O(1) - Constant space is used.
+   * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+   * Space Complexity: O(n) - Additional space is required for the sorted array.
    */
 
   /**
@@ -316,7 +318,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * the key of the leftmost node if the comparison result is greater than, and the key of the
    * rightmost node otherwise. If no node is found, it returns 0.
    */
-  lastKey(beginRoot: BTNKey | N | undefined = this.root, iterationType = this.options.iterationType): BTNKey {
+  lastKey(beginRoot: BTNKey | N | undefined = this.root, iterationType = this.iterationType): BTNKey {
     if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
     else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -324,7 +326,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree.
-   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+   * Space Complexity: O(1) - Constant space is used.
    */
 
   /**
@@ -366,6 +368,11 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
   }
 
+  /**
+   * Time Complexity: O(log n) - Average case for a balanced tree.
+   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+   */
+
   /**
    * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
    * otherwise it returns the key itself.
@@ -379,11 +386,6 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
   }
 
-  /**
-   * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-   */
-
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
    * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -412,7 +414,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: BTNKey | N | undefined = this.root,
-    iterationType = this.options.iterationType
+    iterationType = this.iterationType
   ): N[] {
     beginRoot = this.ensureNotKey(beginRoot);
     if (!beginRoot) return [];
@@ -493,7 +495,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BTNKey | N | undefined = this.root,
-    iterationType = this.options.iterationType
+    iterationType = this.iterationType
   ): ReturnType<C>[] {
     targetNode = this.ensureNotKey(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
@@ -531,18 +533,8 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * Balancing Adjustment:
-   * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-   * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-   *
-   * Use Cases and Efficiency:
-   * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-   * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-   */
-
-  /**
-   * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-   * Space Complexity: O(n) - Additional space is required for the sorted array.
+   * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
+   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
    */
 
   /**
@@ -556,7 +548,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * values:
    * @returns The function `perfectlyBalance` returns a boolean value.
    */
-  perfectlyBalance(iterationType = this.options.iterationType): boolean {
+  perfectlyBalance(iterationType = this.iterationType): boolean {
     const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     this.clear();
@@ -595,8 +587,18 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   }
 
   /**
-   * Time Complexity: O(n) - Visiting each node once.
-   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+   * Balancing Adjustment:
+   * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
+   * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+   *
+   * Use Cases and Efficiency:
+   * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+   * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
+   */
+
+  /**
+   * Time Complexity: O(n) - Building a balanced tree from a sorted array.
+   * Space Complexity: O(n) - Additional space is required for the sorted array.
    */
 
   /**
@@ -608,7 +610,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * to check if the AVL tree is balanced. It can have two possible values:
    * @returns a boolean value.
    */
-  isAVLBalanced(iterationType = this.options.iterationType): boolean {
+  isAVLBalanced(iterationType = this.iterationType): boolean {
     if (!this.root) return true;
 
     let balanced = true;
@@ -652,6 +654,24 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     return balanced;
   }
 
+  /**
+   * Time Complexity: O(n) - Visiting each node once.
+   * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+   */
+
+  init(elements: IterableEntriesOrKeys<V>): void {
+    if (elements) {
+      for (const entryOrKey of elements) {
+        if (Array.isArray(entryOrKey)) {
+          const [key, value] = entryOrKey;
+          this.add(key, value);
+        } else {
+          this.add(entryOrKey);
+        }
+      }
+    }
+  }
+
   protected _setRoot(v: N | undefined) {
     if (v) {
       v.parent = undefined;
@@ -668,7 +688,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * than), CP.lt (less than), or CP.eq (equal).
    */
   protected _compare(a: BTNKey, b: BTNKey): CP {
-    const compared = this.options.comparator!(a, b);
+    const compared = this.comparator(a, b);
     if (compared > 0) return CP.gt;
     else if (compared < 0) return CP.lt;
     else return CP.eq;

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

@@ -10,6 +10,7 @@ import {
   BiTreeDeleteResult,
   BTNCallback,
   BTNKey,
+  IterableEntriesOrKeys,
   IterationType,
   RBTNColor,
   RBTreeOptions,
@@ -43,21 +44,18 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
   extends BST<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
   Sentinel: N = new RedBlackTreeNode<V>(NaN) as unknown as N;
-  override options: RBTreeOptions;
+
 
   /**
    * The constructor function initializes a Red-Black Tree with an optional set of options.
    * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
    * passed to the constructor. It is used to configure the RBTree object with specific options.
    */
-  constructor(options?: RBTreeOptions) {
-    super(options);
-    if (options) {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options }
-    } else {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
-    }
+  constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<RBTreeOptions>) {
+    super([], options);
+
     this._root = this.Sentinel;
+    if (elements) this.init(elements);
   }
 
   protected _root: N;
@@ -77,14 +75,12 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
   }
 
   override createTree(options?: RBTreeOptions): TREE {
-    return new RedBlackTree<V, N, TREE>({ ...this.options, ...options }) as TREE;
+    return new RedBlackTree<V, N, TREE>([], {
+      iterationType: this.iterationType,
+      comparator: this.comparator, ...options
+    }) as TREE;
   }
 
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
@@ -235,6 +231,11 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     return ans;
   }
 
+  /**
+   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Space Complexity: O(1)
+   */
+
   override isRealNode(node: N | undefined): node is N {
     return node !== this.Sentinel && node !== undefined;
   }
@@ -260,11 +261,6 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     iterationType?: IterationType
   ): N | undefined;
 
-  /**
-   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
@@ -290,7 +286,7 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BTNKey | N | undefined = this.root,
-    iterationType = this.options.iterationType
+    iterationType = this.iterationType
   ): N | null | undefined {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     beginRoot = this.ensureNotKey(beginRoot);
@@ -351,11 +347,29 @@ export class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTr
     return y!;
   }
 
+  /**
+   * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+   * Space Complexity: O(1)
+   */
+
   override clear() {
     this._root = this.Sentinel;
     this._size = 0;
   }
 
+  init(elements: IterableEntriesOrKeys<V>): void {
+    if (elements) {
+      for (const entryOrKey of elements) {
+        if (Array.isArray(entryOrKey)) {
+          const [key, value] = entryOrKey;
+          this.add(key, value);
+        } else {
+          this.add(entryOrKey);
+        }
+      }
+    }
+  }
+
   protected override _setRoot(v: N) {
     if (v) {
       v.parent = undefined;

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

@@ -6,7 +6,15 @@
  * @license MIT License
  */
 import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import { BiTreeDeleteResult, BTNCallback, CP, FamilyPosition, IterationType, TreeMultimapNested } from '../../types';
+import {
+  BiTreeDeleteResult,
+  BTNCallback,
+  CP,
+  FamilyPosition,
+  IterableEntriesOrKeys,
+  IterationType,
+  TreeMultimapNested
+} from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -40,21 +48,15 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   extends AVLTree<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
 
-  override options: TreeMultimapOptions;
-
   /**
    * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
    * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
    * TreeMultimap.
    */
-  constructor(options: TreeMultimapOptions = { iterationType: IterationType.ITERATIVE }) {
-    super(options);
-    if (options) {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b, ...options }
-    } else {
-      this.options = { iterationType: IterationType.ITERATIVE, comparator: (a, b) => a - b };
-    }
+  constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<TreeMultimapOptions>) {
+    super([], options);
+    if (elements) this.init(elements);
   }
 
   private _count = 0;
@@ -77,14 +79,12 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   override createTree(options?: TreeMultimapOptions): TREE {
-    return new TreeMultimap<V, N, TREE>({ ...this.options, ...options }) as TREE;
+    return new TreeMultimap<V, N, TREE>([], {
+      iterationType: this.iterationType,
+      comparator: this.comparator, ...options
+    }) as TREE;
   }
 
-  /**
-   * 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.
-   */
-
   /**
    * 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.
@@ -169,8 +169,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * 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(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.
    */
 
   /**
@@ -208,8 +208,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * 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(1) - constant time, as it performs basic pointer assignments.
+   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
    */
 
   /**
@@ -223,7 +223,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.options.iterationType): boolean {
+  override perfectlyBalance(iterationType = this.iterationType): boolean {
     const sorted = this.dfs(node => node, 'in'),
       n = sorted.length;
     if (sorted.length < 1) return false;
@@ -262,8 +262,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * 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(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.
    */
 
   /**
@@ -346,8 +346,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * 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(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.
    */
 
   /**
@@ -358,6 +358,24 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     this._count = 0;
   }
 
+  /**
+   * 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.
+   */
+
+  init(elements: IterableEntriesOrKeys<V>): void {
+    if (elements) {
+      for (const entryOrKey of elements) {
+        if (Array.isArray(entryOrKey)) {
+          const [key, value] = entryOrKey;
+          this.add(key, value);
+        } else {
+          this.add(entryOrKey);
+        }
+      }
+    }
+  }
+
   /**
    * 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.

package/src/data-structures/graph/abstract-graph.ts

@@ -691,7 +691,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; value: VO }>({ comparator: (a, b) => a.key - b.key });
+    const heap = new PriorityQueue<{ key: number; value: VO }>([], { comparator: (a, b) => a.key - b.key });
     heap.add({ key: 0, value: srcVertex });
 
     distMap.set(srcVertex, 0);