min-heap-typed 1.38.7 → 1.38.9

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

@@ -13,7 +13,7 @@ export declare class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeN
     height: number;
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
-export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode> extends BST<V, N> implements IBinaryTree<V, N> {
+export declare class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     /**
      * This is a constructor function for an AVL tree data structure in TypeScript.
      * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the

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

@@ -62,7 +62,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode> implements IBinaryTree<V, N> {
+export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>> implements IBinaryTree<V, N> {
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -285,10 +285,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @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
-     * @param {boolean} [withLevel=false] - The `withLevel` parameter is a boolean flag that determines
-     * whether to include the level of each node in the callback function. If `withLevel` is set
-     * to `true`, the level of each node will be passed as an argument to the callback function. If
-     * `withLevel` is
      * @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.
@@ -296,7 +292,23 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
      * @returns The function `bfs` returns an array of `BFSCallbackReturn<N>[]`.
      */
-    bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(callback?: C, withLevel?: boolean, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
+    bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[];
+    /**
+     * The `listLevels` function takes a binary tree node and a callback function, and returns an array
+     * of arrays representing the levels of the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called on each node in
+     * the tree. It takes a node as input and returns a value. The return type of the callback function
+     * is determined by the generic type `C`.
+     * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
+     * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
+     * from the root node of the binary tree.
+     * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
+     * recursively or iteratively. It can have two possible values:
+     * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
+     * 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>>(callback?: C, beginRoot?: N | null, iterationType?: IterationType): ReturnType<C>[][];
     /**
      * The function returns the predecessor node of a given node in a binary tree.
      * @param {N} node - The parameter "node" represents a node in a binary tree.

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

@@ -821,10 +821,6 @@ class BinaryTree {
      * @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
-     * @param {boolean} [withLevel=false] - The `withLevel` parameter is a boolean flag that determines
-     * whether to include the level of each node in the callback function. If `withLevel` is set
-     * to `true`, the level of each node will be passed as an argument to the callback function. If
-     * `withLevel` is
      * @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.
@@ -832,13 +828,65 @@ class BinaryTree {
      * in the breadth-first search (BFS) algorithm. It can have two possible values:
      * @returns The function `bfs` returns an array of `BFSCallbackReturn<N>[]`.
      */
-    bfs(callback = this._defaultCallbackByKey, withLevel = false, beginRoot = this.root, iterationType = this.iterationType) {
+    bfs(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
         if (!beginRoot)
             return [];
         const ans = [];
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const queue = new queue_1.Queue([beginRoot]);
+            function traverse(level) {
+                if (queue.size === 0)
+                    return;
+                const current = queue.shift();
+                ans.push(callback(current));
+                if (current.left)
+                    queue.push(current.left);
+                if (current.right)
+                    queue.push(current.right);
+                traverse(level + 1);
+            }
+            traverse(0);
+        }
+        else {
+            const queue = new queue_1.Queue([beginRoot]);
+            while (queue.size > 0) {
+                const levelSize = queue.size;
+                for (let i = 0; i < levelSize; i++) {
+                    const current = queue.shift();
+                    ans.push(callback(current));
+                    if (current.left)
+                        queue.push(current.left);
+                    if (current.right)
+                        queue.push(current.right);
+                }
+            }
+        }
+        return ans;
+    }
+    /**
+     * The `listLevels` function takes a binary tree node and a callback function, and returns an array
+     * of arrays representing the levels of the tree.
+     * @param {C} callback - The `callback` parameter is a function that will be called on each node in
+     * the tree. It takes a node as input and returns a value. The return type of the callback function
+     * is determined by the generic type `C`.
+     * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
+     * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
+     * from the root node of the binary tree.
+     * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
+     * recursively or iteratively. It can have two possible values:
+     * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
+     * 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(callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
+        if (!beginRoot)
+            return [];
+        const levelsNodes = [];
         if (iterationType === types_1.IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
-                callback && ans.push(callback(node, withLevel ? level : undefined));
+                if (!levelsNodes[level])
+                    levelsNodes[level] = [];
+                levelsNodes[level].push(callback(node));
                 if (node.left)
                     _recursive(node.left, level + 1);
                 if (node.right)
@@ -851,14 +899,16 @@ class BinaryTree {
             while (stack.length > 0) {
                 const head = stack.pop();
                 const [node, level] = head;
-                callback && ans.push(callback(node, withLevel ? level : undefined));
+                if (!levelsNodes[level])
+                    levelsNodes[level] = [];
+                levelsNodes[level].push(callback(node));
                 if (node.right)
                     stack.push([node.right, level + 1]);
                 if (node.left)
                     stack.push([node.left, level + 1]);
             }
         }
-        return ans;
+        return levelsNodes;
     }
     /**
      * The function returns the predecessor node of a given node in a binary tree.

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

@@ -12,7 +12,7 @@ import { IBinaryTree } from '../../interfaces';
 export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
-export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
     /**
      * The constructor function initializes a binary search tree object with an optional comparator
      * function.

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

@@ -7,7 +7,7 @@ export declare class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNode
     get color(): RBColor;
     set color(value: RBColor);
 }
-export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode> extends BST<V, N> implements IBinaryTree<V, N> {
+export declare class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
     constructor(options?: RBTreeOptions);
     createNode(key: BinaryTreeNodeKey, val?: V): N;
 }

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

@@ -26,7 +26,7 @@ export declare class TreeMultisetNode<V = any, N extends TreeMultisetNode<V, N>
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode> extends AVLTree<V, N> implements IBinaryTree<V, N> {
+export declare class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>> extends AVLTree<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.

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

@@ -77,8 +77,9 @@ export declare class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
+     * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
      * @returns {string[]} an array of strings.
      */
-    getWords(prefix?: string, max?: number): string[];
+    getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
     private _caseProcess;
 }

package/dist/data-structures/trie/trie.js

@@ -226,9 +226,10 @@ class Trie {
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
      * @param {number} max - The max count of words will be found
+     * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
      * @returns {string[]} an array of strings.
      */
-    getWords(prefix = '', max = Number.MAX_SAFE_INTEGER) {
+    getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false) {
         prefix = this._caseProcess(prefix);
         const words = [];
         let found = 0;
@@ -254,7 +255,7 @@ class Trie {
                     startNode = nodeC;
             }
         }
-        if (startNode !== this.root)
+        if (isAllWhenEmptyPrefix || startNode !== this.root)
             dfs(startNode, prefix);
         return words;
     }

package/package.json

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

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

@@ -19,10 +19,9 @@ export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNeste
   }
 }
 
-export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode>
+export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTreeNodeNested<V>>>
   extends BST<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -161,7 +160,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode>
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
+  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};

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

@@ -115,7 +115,8 @@ export class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = BinaryTree
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode> implements IBinaryTree<V, N> {
+export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>>
+  implements IBinaryTree<V, N> {
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -404,7 +405,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) {
@@ -887,7 +888,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,10 +931,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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
-   * @param {boolean} [withLevel=false] - The `withLevel` parameter is a boolean flag that determines
-   * whether to include the level of each node in the callback function. If `withLevel` is set
-   * to `true`, the level of each node will be passed as an argument to the callback function. If
-   * `withLevel` is
    * @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.
@@ -943,7 +940,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
     callback: C = this._defaultCallbackByKey as C,
-    withLevel: boolean = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -951,9 +947,66 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
     const ans: BFSCallbackReturn<N>[] = [];
 
+    if (iterationType === IterationType.RECURSIVE) {
+      const queue = new Queue<N>([beginRoot]);
+
+      function traverse(level: number) {
+        if (queue.size === 0) return;
+
+        const current = queue.shift()!;
+        ans.push(callback(current));
+
+        if (current.left) queue.push(current.left);
+        if (current.right) queue.push(current.right);
+
+        traverse(level + 1);
+      }
+
+      traverse(0);
+    } else {
+      const queue = new Queue<N>([beginRoot]);
+      while (queue.size > 0) {
+        const levelSize = queue.size;
+
+        for (let i = 0; i < levelSize; i++) {
+          const current = queue.shift()!;
+          ans.push(callback(current));
+
+          if (current.left) queue.push(current.left);
+          if (current.right) queue.push(current.right);
+        }
+      }
+    }
+    return ans;
+  }
+
+  /**
+   * The `listLevels` function takes a binary tree node and a callback function, and returns an array
+   * of arrays representing the levels of the tree.
+   * @param {C} callback - The `callback` parameter is a function that will be called on each node in
+   * the tree. It takes a node as input and returns a value. The return type of the callback function
+   * is determined by the generic type `C`.
+   * @param {N | null} beginRoot - The `beginRoot` parameter represents the starting node of the binary tree
+   * traversal. It can be any node in the binary tree. If no node is provided, the traversal will start
+   * from the root node of the binary tree.
+   * @param iterationType - The `iterationType` parameter determines whether the tree traversal is done
+   * recursively or iteratively. It can have two possible values:
+   * @returns The function `listLevels` returns an array of arrays, where each inner array represents a
+   * 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>>(
+    callback: C = this._defaultCallbackByKey as C,
+    beginRoot: N | null = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[][] {
+    if (!beginRoot) return [];
+    const levelsNodes: ReturnType<C>[][] = [];
+
     if (iterationType === IterationType.RECURSIVE) {
       const _recursive = (node: N, level: number) => {
-        callback && ans.push(callback(node, withLevel ? level : undefined));
+        if (!levelsNodes[level]) levelsNodes[level] = [];
+        levelsNodes[level].push(callback(node));
         if (node.left) _recursive(node.left, level + 1);
         if (node.right) _recursive(node.right, level + 1);
       };
@@ -966,12 +1019,14 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
         const head = stack.pop()!;
         const [node, level] = head;
 
-        callback && ans.push(callback(node, withLevel ? level : undefined));
+        if (!levelsNodes[level]) levelsNodes[level] = [];
+        levelsNodes[level].push(callback(node));
         if (node.right) stack.push([node.right, level + 1]);
         if (node.left) stack.push([node.left, level + 1]);
       }
     }
-    return ans;
+
+    return levelsNodes;
   }
 
   /**

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

@@ -24,7 +24,9 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
   }
 }
 
-export class BST<V = any, N extends BSTNode<V, N> = BSTNode> extends BinaryTree<V, N> implements IBinaryTree<V, N> {
+export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
+  extends BinaryTree<V, N>
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.

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

@@ -19,7 +19,9 @@ export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V
   }
 }
 
-export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode> extends BST<V, N> implements IBinaryTree<V, N> {
+export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNested<V>>>
+  extends BST<V, N>
+  implements IBinaryTree<V, N> {
   constructor(options?: RBTreeOptions) {
     super(options);
   }

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

@@ -35,10 +35,9 @@ export class TreeMultisetNode<
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = 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.

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

@@ -105,8 +105,7 @@ 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> {
@@ -554,14 +553,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);
 
@@ -623,7 +622,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 }>((a, b) => a.key - b.key);
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -852,7 +851,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,8 +64,7 @@ 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,12 +51,11 @@ 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 +1,2 @@
-export class TreeMap {}
+export class TreeMap {
+}

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

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

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

@@ -485,7 +485,7 @@ export class SinglyLinkedList<E = any> {
     return count;
   }
 
-  *[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,7 +10,8 @@ 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/queue/deque.ts

@@ -9,7 +9,8 @@ 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
@@ -19,9 +20,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;
   }
 
@@ -156,7 +157,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;
     }

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

@@ -241,9 +241,10 @@ export class Trie {
    * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
    * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
    * @param {number} max - The max count of words will be found
+   * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
    * @returns {string[]} an array of strings.
    */
-  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER): string[] {
+  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false): string[] {
     prefix = this._caseProcess(prefix);
     const words: string[] = [];
     let found = 0;
@@ -270,7 +271,8 @@ export class Trie {
         if (nodeC) startNode = nodeC;
       }
     }
-    if (startNode !== this.root) dfs(startNode, prefix);
+
+    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
 
     return words;
   }

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

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = {[key in Direction]: Direction};
+export type Turning = { [key in Direction]: Direction };
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = {[key: string]: any};
+export type KeyValueObject = { [key: string]: any };
 
-export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
+export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;