min-heap-typed 1.39.2 → 1.39.4

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

@@ -5,21 +5,22 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, OneParamCallback} from '../../types';
+import type {BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback} from '../../types';
 import {CP, IterationType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  constructor(key: BinaryTreeNodeKey, val?: V) {
+  constructor(key: BTNKey, val?: V) {
     super(key, val);
   }
 }
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -38,27 +39,27 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
   /**
    * The function creates a new binary search tree node with the given key and value.
-   * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+   * @param {BTNKey} key - The key parameter is the key value that will be associated with
    * the new node. It is used to determine the position of the node in the binary search tree.
    * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
    * represents the value associated with the node in a binary search tree.
    * @returns a new instance of the BSTNode class with the specified key and value.
    */
-  override createNode(key: BinaryTreeNodeKey, val?: V): N {
+  override createNode(key: BTNKey, val?: V): N {
     return new BSTNode<V, N>(key, val) as N;
   }
 
   /**
    * The `add` function in a binary search tree class inserts a new node with a given key and value
    * into the tree.
-   * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-   * `BinaryTreeNodeKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+   * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+   * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
    * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
    * binary search tree.
    * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
    * was not added or if the parameters were invalid, it returns null or undefined.
    */
-  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
     // TODO support node as a parameter
     let inserted: N | null = null;
     let newNode: N | null = null;
@@ -127,9 +128,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
    * maintaining balance.
-   * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+   * @param {[BTNKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
    * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
-   * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
+   * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
    * `null
    * @param {V[]} data - The values of tree nodes
    * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
@@ -139,13 +140,13 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
 
   override addMany(
-    keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
+    keysOrNodes: (BTNKey | null)[] | (N | null)[],
     data?: V[],
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | null | undefined)[] {
     // TODO this addMany function is inefficient, it should be optimized
-    function hasNoNull(arr: (BinaryTreeNodeKey | null)[] | (N | null)[]): arr is BinaryTreeNodeKey[] | N[] {
+    function hasNoNull(arr: (BTNKey | null)[] | (N | null)[]): arr is BTNKey[] | N[] {
       return arr.indexOf(null) === -1;
     }
 
@@ -153,17 +154,15 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BinaryTreeNodeKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BTNKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BinaryTreeNodeKey | N, N['val']][]): arr is [N, N['val']][] {
+    function isNodeOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [N, N['val']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(
-      arr: [BinaryTreeNodeKey | N, N['val']][]
-    ): arr is [BinaryTreeNodeKey, N['val']][] {
+    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [BTNKey, N['val']][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }
@@ -180,7 +179,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
     sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
     sortedData = sorted.map(([, val]) => val);
-    const recursive = (arr: (BinaryTreeNodeKey | null | N)[], data?: (V | undefined)[]) => {
+    const recursive = (arr: (BTNKey | null | N)[], data?: (V | undefined)[]) => {
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
@@ -220,7 +219,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * callback.
    * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
    * property of the binary tree node that you want to search for. It can be either a specific key
-   * value (`BinaryTreeNodeKey`) or a custom callback function (`OneParamCallback<N>`) that determines
+   * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
    * whether a node matches the desired property.
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired property. It takes a node as input and returns a boolean value indicating
@@ -233,9 +232,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns either the first node that matches the given nodeProperty and callback, or null if no
    * matching node is found.
    */
-  override get<C extends OneParamCallback<N>>(
+  override get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -257,7 +256,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: N | null = this.root, iterationType = this.iterationType): BinaryTreeNodeKey {
+  lastKey(beginRoot: N | null = 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;
@@ -267,11 +266,11 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
    * using either recursive or iterative traversal.
    * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
-   * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
+   * of the binary tree node that you want to search for. It can be either a `BTNKey` or a
    * generic type `N`.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
-   * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+   * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
    * a
    * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
    * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -284,9 +283,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * traverse the binary tree. It can have one of the following values:
    * @returns an array of nodes (N[]).
    */
-  override getNodes<C extends OneParamCallback<N>>(
+  override getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -304,7 +303,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
         if (!cur.left && !cur.right) return;
         // TODO potential bug
-        if (callback === this._defaultCallbackByKey) {
+        if (callback === ((node: N) => node.key)) {
           if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && _traverse(cur.left);
           if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && _traverse(cur.right);
         } else {
@@ -325,7 +324,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this._defaultCallbackByKey) {
+          if (callback === ((node: N) => node.key)) {
             if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && queue.push(cur.left);
             if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && queue.push(cur.right);
           } else {
@@ -350,22 +349,22 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
    * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
    * of the following values:
-   * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
+   * @param {BTNKey | N | null} targetNode - The `targetNode` parameter in the
    * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
    * start. It can be either a reference to a specific node (`N`), the key of a node
-   * (`BinaryTreeNodeKey`), or `null` to
+   * (`BTNKey`), or `null` to
    * @param iterationType - The `iterationType` parameter determines whether the traversal should be
    * done recursively or iteratively. It can have two possible values:
-   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
+   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
-  lesserOrGreaterTraverse<C extends OneParamCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+  lesserOrGreaterTraverse<C extends BTNCallback<N>>(
+    callback: C = ((node: N) => node.key) as C,
     lesserOrGreater: CP = CP.lt,
-    targetNode: BinaryTreeNodeKey | N | null = this.root,
+    targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof targetNode === 'number') targetNode = this.get(targetNode);
-    const ans: ReturnType<OneParamCallback<N>>[] = [];
+    const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;
     if (!this.root) return ans;
@@ -508,12 +507,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The function compares two values using a comparator function and returns whether the first value
    * is greater than, less than, or equal to the second value.
-   * @param {BinaryTreeNodeKey} a - The parameter "a" is of type BinaryTreeNodeKey.
-   * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code represents a BinaryTreeNodeKey.
+   * @param {BTNKey} a - The parameter "a" is of type BTNKey.
+   * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
    * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
    * than), CP.lt (less than), or CP.eq (equal).
    */
-  protected _compare(a: BinaryTreeNodeKey, b: BinaryTreeNodeKey): CP {
+  protected _compare(a: BTNKey, b: BTNKey): CP {
     const compared = this._comparator(a, b);
     if (compared > 0) return CP.gt;
     else if (compared < 0) return CP.lt;

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

@@ -1,9 +1,9 @@
-import {BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
+import {BTNKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {BST, BSTNode} from './bst';
 
 export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-  constructor(key: BinaryTreeNodeKey, val?: V) {
+  constructor(key: BTNKey, val?: V) {
     super(key, val);
     this._color = RBColor.RED;
   }
@@ -21,16 +21,17 @@ export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V
 
 export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   constructor(options?: RBTreeOptions) {
     super(options);
   }
 
-  override createNode(key: BinaryTreeNodeKey, val?: V): N {
+  override createNode(key: BTNKey, val?: V): N {
     return new RBTreeNode(key, val) as N;
   }
 
-  // override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V): N | null | undefined {
+  // override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
   //   const inserted = super.add(keyOrNode, val);
   //   if (inserted) this._fixInsertViolation(inserted);
   //   return inserted;
@@ -204,7 +205,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   //   node.right = null;
   // }
   //
-  // override delete(keyOrNode: BinaryTreeNodeKey | N): BinaryTreeDeletedResult<N>[] {
+  // override delete(keyOrNode: BTNKey | N): BinaryTreeDeletedResult<N>[] {
   //   const node = this.get(keyOrNode);
   //   const result: BinaryTreeDeletedResult<N>[] = [{deleted: undefined, needBalanced: null}];
   //   if (!node) return result; // Node does not exist

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, OneParamCallback} from '../../types';
+import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, BTNCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -18,7 +18,7 @@ export class TreeMultisetNode<
 
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-   * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
+   * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
    * of the binary tree node.
    * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
    * tree node. If no value is provided, it will be `undefined`.
@@ -26,7 +26,7 @@ export class TreeMultisetNode<
    * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
    * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(key: BinaryTreeNodeKey, val?: V, count = 1) {
+  constructor(key: BTNKey, val?: V, count = 1) {
     super(key, val);
     this.count = count;
   }
@@ -37,7 +37,8 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -56,22 +57,22 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
 
   /**
    * The function creates a new BSTNode with the given key, value, and count.
-   * @param {BinaryTreeNodeKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+   * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
    * distinguish one node from another in the tree.
    * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
    * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
    * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(key: BinaryTreeNodeKey, val?: V, count?: number): N {
+  override createNode(key: BTNKey, val?: V, count?: number): N {
     return new TreeMultisetNode(key, val, count) as N;
   }
 
   /**
    * The `add` function adds a new node to a binary search tree, updating the count if the key already
    * exists, and balancing the tree if necessary.
-   * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-   * `BinaryTreeNodeKey` (which represents the key of the node to be added), a `N` (which represents a
+   * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+   * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
    * node to be added), or `null` (which represents a null node).
    * @param [val] - The `val` parameter represents the value associated with the key that is being
    * added to the binary tree.
@@ -80,7 +81,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * count is specified, the default count will be 1.
    * @returns The function `add` returns a value of type `N | null | undefined`.
    */
-  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V, count = 1): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, val?: V, count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
     if (keyOrNode instanceof TreeMultisetNode) {
@@ -184,14 +185,14 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
   /**
    * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the
    * inserted nodes.
-   * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
-   * added to the multiset. Each element can be either a BinaryTreeNodeKey or a TreeMultisetNode.
+   * @param {(BTNKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
+   * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode.
    * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond
    * to the keys or nodes being added to the multiset. It is used to associate additional data with
    * each key or node.
    * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
    */
-  override addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[] {
+  override addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[] {
     const inserted: (N | null | undefined)[] = [];
 
     for (let i = 0; i < keysOrNodes.length; i++) {
@@ -262,21 +263,21 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
    * node along with the parent node that needs to be balanced.
    * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
-   * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+   * `BTNKey` or a generic type `N`. It represents the property of the node that we are
    * searching for. It can be a specific key value or any other property of the node.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`
+   * `((node: N) => node.key)`
    * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
    * being deleted. If set to true, the count of the node will not be considered and the node will be
    * deleted regardless of its count. If set to false (default), the count of the node will be
    * decremented by 1 and
    * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete<C extends OneParamCallback<N>>(
+  override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     ignoreCount = false
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];

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

@@ -105,7 +105,8 @@ export abstract class AbstractEdge<V = any> {
 export abstract class AbstractGraph<
   V extends AbstractVertex<any> = AbstractVertex<any>,
   E extends AbstractEdge<any> = AbstractEdge<any>
-> implements IGraph<V, E> {
+> implements IGraph<V, E>
+{
   private _vertices: Map<VertexKey, V> = new Map<VertexKey, V>();
 
   get vertices(): Map<VertexKey, V> {
@@ -553,14 +554,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-    distMap.forEach((d, v) => {
-      if (v !== srcVertex) {
-        if (d < minDist) {
-          minDist = d;
-          if (genPaths) minDest = v;
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
         }
-      }
-    });
+      });
 
     genPaths && getPaths(minDest);
 
@@ -622,7 +623,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; val: V }>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{key: number; val: V}>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -851,7 +852,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): { costs: number[][]; predecessor: (V | null)[][] } {
+  floyd(): {costs: number[][]; predecessor: (V | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 

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

@@ -64,7 +64,8 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
 
 export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E> {
+  implements IGraph<V, E>
+{
   /**
    * The constructor function initializes an instance of a class.
    */

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

@@ -51,11 +51,12 @@ export class UndirectedEdge<V = number> extends AbstractEdge<V> {
 }
 
 export class UndirectedGraph<
-  V extends UndirectedVertex<any> = UndirectedVertex,
-  E extends UndirectedEdge<any> = UndirectedEdge
->
+    V extends UndirectedVertex<any> = UndirectedVertex,
+    E extends UndirectedEdge<any> = UndirectedEdge
+  >
   extends AbstractGraph<V, E>
-  implements IGraph<V, E> {
+  implements IGraph<V, E>
+{
   /**
    * The constructor initializes a new Map object to store edges.
    */

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

@@ -157,7 +157,7 @@ export class HashMap<K, V> {
     }
   }
 
-  * entries(): IterableIterator<[K, V]> {
+  *entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {

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

@@ -1,2 +1 @@
-export class TreeMap {
-}
+export class TreeMap {}

package/src/data-structures/hash/tree-set.ts

@@ -1,2 +1 @@
-export class TreeSet {
-}
+export class TreeSet {}

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

@@ -11,7 +11,7 @@ export class Heap<E = any> {
   protected nodes: E[] = [];
   protected readonly comparator: Comparator<E>;
 
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     this.comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
       this.nodes = options.nodes;
@@ -39,7 +39,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
     return new Heap<E>(options);
   }
 

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       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');

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       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');

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

@@ -628,7 +628,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -590,7 +590,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: { row: number; col: number; initialVal?: V }) {
+  constructor(options: {row: number; col: number; initialVal?: V}) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

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

@@ -10,8 +10,7 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {
-  }
+  ) {}
 
   /**
    * The function checks if the x and y values of a point are both zero.

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

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       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');

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

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       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');

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

@@ -10,7 +10,7 @@ import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     super(options);
   }
 }

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

@@ -9,8 +9,7 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {
-}
+export class Deque<E = any> extends DoublyLinkedList<E> {}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -20,9 +19,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  private _nodes: { [key: number]: E } = {};
+  private _nodes: {[key: number]: E} = {};
 
-  get nodes(): { [p: number]: E } {
+  get nodes(): {[p: number]: E} {
     return this._nodes;
   }
 
@@ -157,7 +156,7 @@ export class ObjectDeque<E = number> {
     return this._size <= 0;
   }
 
-  protected _seNodes(value: { [p: number]: E }) {
+  protected _seNodes(value: {[p: number]: E}) {
     this._nodes = value;
   }
 

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

@@ -183,7 +183,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }