min-heap-typed 1.42.2 → 1.42.3

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -79,7 +79,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * Get the number of nodes in the binary tree.
      */
     get size(): number;
-    protected defaultOneParamCallback: (node: N) => number;
     /**
      * Creates a new instance of BinaryTreeNode with the given key and value.
      * @param {BTNKey} key - The key for the new node.
@@ -289,6 +288,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * binary tree nodes in a specific order.
      */
     [Symbol.iterator](node?: N | null): Generator<BTNKey, void, undefined>;
+    protected defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.

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

@@ -1034,7 +1034,6 @@ class BinaryTree {
         }
         return y;
     }
-    // --- start additional methods ---
     /**
      * 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.
@@ -1133,6 +1132,7 @@ class BinaryTree {
         }
         return ans;
     }
+    // --- start additional methods ---
     /**
      * The above function is an iterator for a binary tree that can be used to traverse the tree in
      * either an iterative or recursive manner.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.42.2",
+  "version": "1.42.3",
   "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.42.2"
+    "data-structure-typed": "^1.42.3"
   }
 }

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

@@ -108,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>
+{
   iterationType: IterationType = IterationType.ITERATIVE;
 
   /**
@@ -140,8 +141,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this._size;
   }
 
-  protected defaultOneParamCallback = (node: N) => node.key;
-
   /**
    * Creates a new instance of BinaryTreeNode with the given key and value.
    * @param {BTNKey} key - The key for the new node.
@@ -390,7 +389,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) {
@@ -850,21 +849,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N>>(
     callback?: C,
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   subTreeTraverse<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: BTNKey | N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The function `subTreeTraverse` traverses a binary tree and applies a callback function to each
@@ -908,7 +907,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
       _traverse(beginRoot);
     } else {
-      const stack: (N| null)[] = [beginRoot];
+      const stack: (N | null)[] = [beginRoot];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -933,7 +932,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   dfs<C extends BTNCallback<N>>(
     callback?: C,
@@ -941,7 +940,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   dfs<C extends BTNCallback<N | null>>(
     callback?: C,
@@ -949,7 +948,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The `dfs` function performs a depth-first search traversal on a binary tree, executing a callback
@@ -1019,7 +1018,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();
@@ -1066,21 +1065,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N>>(
     callback?: C,
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   bfs<C extends BTNCallback<N | null>>(
     callback?: C,
     beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[]
+  ): ReturnType<C>[];
 
   /**
    * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
@@ -1123,7 +1122,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
           if (current.right) queue.push(current.right);
         }
 
-
         traverse(level + 1);
       };
 
@@ -1144,7 +1142,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
             if (current.left) queue.push(current.left);
             if (current.right) queue.push(current.right);
           }
-
         }
       }
     }
@@ -1152,25 +1149,25 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   }
 
   listLevels<C extends BTNCallback<N>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: false
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: undefined
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   listLevels<C extends BTNCallback<N | null>>(
-    callback?: C ,
-    beginRoot?: N | null ,
+    callback?: C,
+    beginRoot?: N | null,
     iterationType?: IterationType,
     includeNull?: true
-  ): ReturnType<C>[][]
+  ): ReturnType<C>[][];
 
   /**
    * The `listLevels` function takes a binary tree node and a callback function, and returns an array
@@ -1204,7 +1201,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         if (includeNull) {
           if (node && node.left !== undefined) _recursive(node.left, level + 1);
           if (node && node.right !== undefined) _recursive(node.right, level + 1);
-        } else  {
+        } else {
           if (node && node.left) _recursive(node.left, level + 1);
           if (node && node.right) _recursive(node.right, level + 1);
         }
@@ -1224,7 +1221,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         if (includeNull) {
           if (node && node.right !== undefined) stack.push([node.right, level + 1]);
           if (node && node.left !== undefined) stack.push([node.left, level + 1]);
-        } else  {
+        } else {
           if (node && node.right) stack.push([node.right, level + 1]);
           if (node && node.left) stack.push([node.left, level + 1]);
         }
@@ -1273,8 +1270,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return y;
   }
 
-  // --- start additional methods ---
-
   /**
    * 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.
@@ -1374,6 +1369,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
+  // --- start additional methods ---
+
   /**
    * The above function is an iterator for a binary tree that can be used to traverse the tree in
    * either an iterative or recursive manner.
@@ -1383,7 +1380,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
    * binary tree nodes in a specific order.
    */
-  * [Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
+  *[Symbol.iterator](node = this.root): Generator<BTNKey, void, undefined> {
     if (!node) {
       return;
     }
@@ -1416,6 +1413,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
   }
 
+  protected defaultOneParamCallback = (node: N) => node.key;
+
   /**
    * Swap the data of two nodes in the binary tree.
    * @param {N} srcNode - The source node to swap.

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

@@ -64,7 +64,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO> {
+> implements IGraph<V, E, VO, EO>
+{
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -234,7 +235,7 @@ export abstract class AbstractGraph<
       return [];
     }
 
-    const stack: { vertex: VO, path: VO[] }[] = [];
+    const stack: {vertex: VO; path: VO[]}[] = [];
     stack.push({vertex: vertex1, path: [vertex1]});
 
     while (stack.length > 0) {
@@ -256,7 +257,6 @@ export abstract class AbstractGraph<
     return paths;
   }
 
-
   /**
    * The function calculates the sum of weights along a given path.
    * @param {VO[]} path - An array of vertices (VO) representing a path in a graph.
@@ -366,7 +366,6 @@ export abstract class AbstractGraph<
       } else {
         return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
       }
-
     } else {
       // DFS
       let minPath: VO[] = [];
@@ -519,14 +518,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);
 
@@ -588,7 +587,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);
@@ -812,7 +811,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
    */
-  floydWarshall(): { costs: number[][]; predecessor: (VO | null)[][] } {
+  floydWarshall(): {costs: number[][]; predecessor: (VO | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -876,7 +875,12 @@ export abstract class AbstractGraph<
    * are arrays of vertices that form cycles within the SCCs.
    * @returns The function `tarjan` returns an object with the following properties:
    */
-  tarjan(needCutVertexes: boolean = false, needBridges: boolean = false, needSCCs: boolean = true, needCycles: boolean = false) {
+  tarjan(
+    needCutVertexes: boolean = false,
+    needBridges: boolean = false,
+    needSCCs: boolean = true,
+    needCycles: boolean = false
+  ) {
     // !! in undirected graph we will not let child visit parent when dfs
     // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
     // !! bridge: low(child) > dfn(cur)