min-heap-typed 1.38.9 → 1.39.1

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

@@ -6,16 +6,8 @@
  * @license MIT License
  */
 
-import type {
-  BFSCallback,
-  BFSCallbackReturn,
-  BinaryTreeNodeKey,
-  BinaryTreeNodeNested,
-  BinaryTreeOptions,
-  MapCallback,
-  MapCallbackReturn
-} from '../../types';
-import {BinaryTreeDeletedResult, DefaultMapCallback, DFSOrderPattern, FamilyPosition, IterationType} from '../../types';
+import type {OneParamCallback, BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions} from '../../types';
+import {BinaryTreeDeletedResult, DFSOrderPattern, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {trampoline} from '../../utils';
 import {Queue} from '../queue';
@@ -116,7 +108,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -285,10 +278,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
   }
 
-  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N): BinaryTreeDeletedResult<N>[];
-
-  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
-
   /**
    * The `delete` function removes a node from a binary search tree and returns the deleted node along
    * with the parent node that needs to be balanced.
@@ -303,13 +292,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * included in the result. The `callback` parameter has a default value of
    * `this._defaultCallbackByKey`, which
    */
-  delete<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  delete<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
 
     const curr = this.get(identifier, callback);
     if (!curr) return bstDeletedResult;
@@ -320,7 +309,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
     if (!curr.left) {
       if (!parent) {
-        if (curr.right !== undefined) this._setRoot(curr.right);
+        // Handle the case when there's only one root node
+        this._setRoot(null);
       } else {
         const {familyPosition: fp} = curr;
         if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
@@ -405,7 +395,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         return -1;
       }
 
-      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
+      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -489,29 +479,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
   }
 
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, onlyOne: boolean): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, onlyOne: boolean): N[];
-
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    onlyOne: boolean,
-    beginRoot: N | null
-  ): N[];
-
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    onlyOne: boolean,
-    beginRoot: N | null,
-    iterationType: IterationType
-  ): N[];
-
   /**
    * The function `getNodes` returns an array of nodes that match a given node property, using either
    * recursive or iterative traversal.
@@ -533,15 +500,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * traverse the binary tree. It can have two possible values:
    * @returns The function `getNodes` returns an array of nodes (`N[]`).
    */
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  getNodes<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): N[] {
     if (!beginRoot) return [];
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     const ans: N[] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -574,14 +541,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, beginRoot: N | null): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, beginRoot: N | null): boolean;
-
   /**
    * The function checks if a binary tree has a node with a given property or key.
    * @param {BinaryTreeNodeKey | N} identifier - The `identifier` parameter is the key or value of
@@ -599,32 +558,17 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for nodes in the binary tree. It can have one of the following values:
    * @returns a boolean value.
    */
-  has<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  has<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): boolean {
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     // TODO may support finding node by value equal
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, beginRoot: N | null): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, beginRoot: N | null): N | null;
-
-  get<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    beginRoot: N | null,
-    iterationType: IterationType
-  ): N | null;
-
   /**
    * The function `get` returns the first node in a binary tree that matches the given property or key.
    * @param {BinaryTreeNodeKey | N} identifier - The `identifier` parameter is the key or value of
@@ -640,13 +584,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for a node in the binary tree. It can have one of the following values:
    * @returns either the found node (of type N) or null if no node is found.
    */
-  get<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  get<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     // TODO may support finding node by value equal
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
@@ -750,7 +694,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * possible values:
    * @returns The function `isSubtreeBST` returns a boolean value.
    */
-  isSubtreeBST(beginRoot: N, iterationType = this.iterationType): boolean {
+  isSubtreeBST(beginRoot: N | null, iterationType = this.iterationType): boolean {
     // TODO there is a bug
     if (!beginRoot) return true;
 
@@ -805,16 +749,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * start from the root of the tree.
    * @param iterationType - The `iterationType` parameter determines the type of traversal to be
    * performed on the binary tree. It can have two possible values:
-   * @returns The function `subTreeTraverse` returns an array of `MapCallbackReturn<N>`.
+   * @returns The function `subTreeTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
    */
-  subTreeTraverse<C extends MapCallback<N>>(
+  subTreeTraverse<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: BinaryTreeNodeKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
 
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (!beginRoot) return ans;
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -852,16 +796,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * is `null`, an empty array will be returned.
    * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
    * iteration used in the depth-first search algorithm. It can have two possible values:
-   * @returns The function `dfs` returns an array of `MapCallbackReturn<N>` values.
+   * @returns The function `dfs` returns an array of `ReturnType<OneParamCallback<N>>` values.
    */
-  dfs<C extends MapCallback<N>>(
+  dfs<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
     iterationType: IterationType = IterationType.ITERATIVE
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (node: N) => {
         switch (pattern) {
@@ -888,7 +832,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
+      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -930,22 +874,22 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function on each node.
    * @param callback - The `callback` parameter is a function that will be called for each node in the
    * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-   * `BFSCallbackReturn<N>`. The default value for this parameter is `this._defaultCallbackByKey
+   * `ReturnType<OneParamCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
    * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
    * will not be performed and an empty array will be returned.
    * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
    * in the breadth-first search (BFS) algorithm. It can have two possible values:
-   * @returns The function `bfs` returns an array of `BFSCallbackReturn<N>[]`.
+   * @returns The function `bfs` returns an array of `ReturnType<OneParamCallback<N>>[]`.
    */
-  bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
+  bfs<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
 
-    const ans: BFSCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
       const queue = new Queue<N>([beginRoot]);
@@ -995,7 +939,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * level in a binary tree. Each inner array contains the return type of the provided callback
    * function `C` applied to the nodes at that level.
    */
-  listLevels<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
+  listLevels<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -1054,7 +998,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
    * algorithm and returns an array of values obtained by applying a callback function to each node.
    * @param callback - The `callback` parameter is a function that will be called on each node in the
-   * tree. It takes a node of type `N` as input and returns a value of type `MapCallbackReturn<N>`. The
+   * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<OneParamCallback<N>>`. The
    * default value for this parameter is `this._defaultCallbackByKey`.
    * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
    * determines the order in which the nodes of a binary tree are traversed. It can have one of the
@@ -1062,15 +1006,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the Morris
    * traversal. It specifies the root node of the tree from which the traversal should begin. If
    * `beginRoot` is `null`, an empty array will be returned.
-   * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
+   * @returns The `morris` function returns an array of `ReturnType<OneParamCallback<N>>` values.
    */
-  morris<C extends MapCallback<N>>(
+  morris<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root
   ): ReturnType<C>[] {
     if (beginRoot === null) return [];
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
 
     let cur: N | null | undefined = beginRoot;
     const _reverseEdge = (node: N | null | undefined) => {
@@ -1177,7 +1121,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * the tree's structure should be restored to its original state to maintain the tree's integrity.
    * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
    */
-  protected _defaultCallbackByKey: DefaultMapCallback<N> = node => node.key;
+  protected _defaultCallbackByKey: OneParamCallback<N, BinaryTreeNodeKey> = node => node.key;
 
   /**
    * The function `_addTo` adds a new node to a binary tree if there is an available position.

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

@@ -5,14 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {
-  BinaryTreeNodeKey,
-  BSTComparator,
-  BSTNodeNested,
-  BSTOptions,
-  MapCallback,
-  MapCallbackReturn
-} from '../../types';
+import type {BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, OneParamCallback} from '../../types';
 import {CP, IterationType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
@@ -26,7 +19,8 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
 
 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.
@@ -227,7 +221,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 (`MapCallback<N>`) that determines
+   * value (`BinaryTreeNodeKey`) or a custom callback function (`OneParamCallback<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
@@ -240,8 +234,8 @@ 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 MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  override get<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
@@ -291,8 +285,8 @@ 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 MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  override getNodes<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
@@ -363,16 +357,16 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * (`BinaryTreeNodeKey`), 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 `MapCallbackReturn<N>`.
+   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
    */
-  lesserOrGreaterTraverse<C extends MapCallback<N>>(
+  lesserOrGreaterTraverse<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BinaryTreeNodeKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof targetNode === 'number') targetNode = this.get(targetNode);
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;
     if (!this.root) return ans;

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

@@ -21,7 +21,8 @@ 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);
   }

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, MapCallback} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, OneParamCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -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.
@@ -274,7 +275,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * decremented by 1 and
    * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete<C extends MapCallback<N>>(
+  override delete<C extends OneParamCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultCallbackByKey as C,
     ignoreCount = false

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> {
@@ -130,7 +131,7 @@ export abstract class AbstractGraph<
    */
   abstract createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
 
-  abstract removeEdge(edge: E): E | null;
+  abstract deleteEdge(edge: E): E | null;
 
   abstract getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
 
@@ -179,12 +180,12 @@ export abstract class AbstractGraph<
   }
 
   /**
-   * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
    * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  removeVertex(vertexOrKey: V | VertexKey): boolean {
+  deleteVertex(vertexOrKey: V | VertexKey): boolean {
     const vertexKey = this._getVertexKey(vertexOrKey);
     return this._vertices.delete(vertexKey);
   }
@@ -196,10 +197,10 @@ export abstract class AbstractGraph<
    * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
    * were removed.
    */
-  removeAllVertices(vertices: V[] | VertexKey[]): boolean {
+  removeManyVertices(vertices: V[] | VertexKey[]): boolean {
     const removed: boolean[] = [];
     for (const v of vertices) {
-      removed.push(this.removeVertex(v));
+      removed.push(this.deleteVertex(v));
     }
     return removed.length > 0;
   }
@@ -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 }>((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.
    */
@@ -153,7 +154,7 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * @param {V | VertexKey} destOrKey - The `destOrKey` parameter represents the destination vertex or its ID.
    * @returns the removed edge (E) if it exists, or null if either the source or destination vertex does not exist.
    */
-  removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
+  deleteEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null {
     const src: V | null = this._getVertex(srcOrKey);
     const dest: V | null = this._getVertex(destOrKey);
     let removed: E | null = null;
@@ -177,9 +178,9 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * The function removes an edge from a graph and returns the removed edge, or null if the edge was not found.
    * @param {E} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
    * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `removeEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
+   * @returns The method `deleteEdge` returns the removed edge (`E`) if it exists, or `null` if the edge does not exist.
    */
-  removeEdge(edge: E): E | null {
+  deleteEdge(edge: E): E | null {
     let removed: E | null = null;
     const src = this._getVertex(edge.src);
     const dest = this._getVertex(edge.dest);
@@ -206,12 +207,12 @@ export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E ext
    * the second vertex in the edge that needs to be removed.
    * @returns an array of removed edges (E[]).
    */
-  removeEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
+  deleteEdgesBetween(v1: VertexKey | V, v2: VertexKey | V): E[] {
     const removed: E[] = [];
 
     if (v1 && v2) {
-      const v1ToV2 = this.removeEdgeSrcToDest(v1, v2);
-      const v2ToV1 = this.removeEdgeSrcToDest(v2, v1);
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
 
       v1ToV2 && removed.push(v1ToV2);
       v2ToV1 && removed.push(v2ToV1);

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

@@ -109,9 +109,9 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
    */
   override createVertex(
     key: VertexKey,
-    val?: V['val'],
     lat: number = this.origin[0],
-    long: number = this.origin[1]
+    long: number = this.origin[1],
+    val?: V['val']
   ): V {
     return new MapVertex(key, lat, long, val) as V;
   }

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.
    */
@@ -127,7 +128,7 @@ export class UndirectedGraph<
    * (VertexKey). It represents the second vertex of the edge that needs to be removed.
    * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
    */
-  removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
+  deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null {
     const vertex1: V | null = this._getVertex(v1);
     const vertex2: V | null = this._getVertex(v2);
 
@@ -148,12 +149,12 @@ export class UndirectedGraph<
   }
 
   /**
-   * The removeEdge function removes an edge between two vertices in a graph.
+   * The deleteEdge function removes an edge between two vertices in a graph.
    * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
    * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
    */
-  removeEdge(edge: E): E | null {
-    return this.removeEdgeBetween(edge.vertices[0], edge.vertices[1]);
+  deleteEdge(edge: E): E | null {
+    return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
   }
 
   /**

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 {}