min-heap-typed 1.49.9 → 1.50.0

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

@@ -13,7 +13,7 @@ import type {
   BTNodePureExemplar,
   KeyOrNodeOrEntry
 } from '../../types';
-import { BSTVariant, CP, IterationType } from '../../types';
+import { BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
@@ -83,14 +83,13 @@ export class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNeste
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
 export class BST<
-    K = any,
-    V = any,
-    N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>,
-    TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>,
+  TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>
+>
   extends BinaryTree<K, V, N, TREE>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   /**
    * This is the constructor function for a binary search tree class in TypeScript, which initializes
    * the tree with optional keysOrNodesOrEntries and options.
@@ -172,7 +171,7 @@ export class BST<
       } else {
         node = this.createNode(key, value);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value);
     } else {
       return;
@@ -213,16 +212,6 @@ export class BST<
     return res;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof BSTNode);
-  }
-
   /**
    * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, N>`.
@@ -408,43 +397,6 @@ export class BST<
     return inserted;
   }
 
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
-   */
-
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   *
-   * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-   * leftmost node if the comparison result is greater than.
-   * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-   * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
-   * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-   * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-   * 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: KeyOrNodeOrEntry<K, V, N> = this.root): K | undefined {
-    let current = this.ensureNode(beginRoot);
-    if (!current) return undefined;
-
-    if (this._variant === BSTVariant.STANDARD) {
-      // For BSTVariant.MIN, find the rightmost node
-      while (current.right !== undefined) {
-        current = current.right;
-      }
-    } else {
-      // For BSTVariant.MAX, find the leftmost node
-      while (current.left !== undefined) {
-        current = current.left;
-      }
-    }
-    return current.key;
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -574,6 +526,157 @@ export class BST<
     return ans;
   }
 
+  // /**
+  //  * The function overrides the subTreeTraverse method and returns the result of calling the super
+  //  * method with the provided arguments.
+  //  * @param {C} callback - The `callback` parameter is a function that will be called for each node in
+  //  * the subtree traversal. It should accept a single parameter of type `N`, which represents a node in
+  //  * the tree. The return type of the callback function can be any type.
+  //  * @param beginRoot - The `beginRoot` parameter is the starting point for traversing the subtree. It
+  //  * can be either a key, a node, or an entry.
+  //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+  //  * be performed during the traversal of the subtree. It can have one of the following values:
+  //  * @returns The method is returning an array of the return type of the callback function.
+  //  */
+  // override subTreeTraverse<C extends BTNCallback<N>>(
+  //   callback: C = this._defaultOneParamCallback as C,
+  //   beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+  //   iterationType = this.iterationType
+  // ): ReturnType<C>[] {
+  //   return super.subTreeTraverse(callback, beginRoot, iterationType, false);
+  // }
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   */
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   *
+   * The function overrides the depth-first search method and returns an array of the return types of
+   * the callback function.
+   * @param {C} callback - The `callback` parameter is a function that will be called for each node
+   * during the depth-first search traversal. It is an optional parameter and if not provided, a
+   * default callback function will be used.
+   * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter specifies the order in which the
+   * nodes are visited during the depth-first search. It can have one of the following values:
+   * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for the
+   * Depth-First Search (DFS) traversal. It can be either a key, a node, or an entry in the tree. If no
+   * value is provided, the DFS traversal will start from the root of the tree.
+   * @param {IterationType} iterationType - The `iterationType` parameter specifies the type of
+   * iteration to be used during the Depth-First Search (DFS) traversal. It can have one of the
+   * following values:
+   * @returns The method is returning an array of the return type of the callback function.
+   */
+  override dfs<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    pattern: DFSOrderPattern = 'in',
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType: IterationType = IterationType.ITERATIVE
+  ): ReturnType<C>[] {
+    return super.dfs(callback, pattern, beginRoot, iterationType, false);
+  }
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   */
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   *
+   * The function overrides the breadth-first search method and returns an array of the return types of
+   * the callback function.
+   * @param {C} callback - The `callback` parameter is a function that will be called for each node
+   * visited during the breadth-first search traversal. It is an optional parameter and if not
+   * provided, a default callback function will be used.
+   * @param beginRoot - The `beginRoot` parameter is the starting point for the breadth-first search
+   * traversal. It can be either a key, a node, or an entry in the tree. If not specified, the root of
+   * the tree is used as the starting point.
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed during the breadth-first search (BFS) traversal. It determines the order in which the
+   * nodes are visited.
+   * @returns The method is returning an array of the return type of the callback function.
+   */
+  override bfs<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[] {
+    return super.bfs(callback, beginRoot, iterationType, false);
+  }
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   */
+
+  /**
+   * Time complexity: O(n)
+   * Space complexity: O(n)
+   *
+   * The function overrides the listLevels method and returns an array of arrays containing the return
+   * type of the callback function for each level of the tree.
+   * @param {C} callback - The `callback` parameter is a generic type `C` that extends
+   * `BTNCallback<N>`. It represents a callback function that will be called for each node in the tree
+   * during the level listing process.
+   * @param beginRoot - The `beginRoot` parameter is used to specify the starting point for listing the
+   * levels of a binary tree. It can be either a key, a node, or an entry in the binary tree. If not
+   * provided, the root of the binary tree is used as the starting point.
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed on the tree. It determines the order in which the nodes are visited during the
+   * iteration.
+   * @returns The method is returning a two-dimensional array of the return type of the callback
+   * function.
+   */
+  override listLevels<C extends BTNCallback<N>>(
+    callback: C = this._defaultOneParamCallback as C,
+    beginRoot: KeyOrNodeOrEntry<K, V, N> = this.root,
+    iterationType = this.iterationType
+  ): ReturnType<C>[][] {
+    return super.listLevels(callback, beginRoot, iterationType, false);
+  }
+
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   * Adding each element individually in a balanced tree. Additional space is required for the sorted array.
+   */
+
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+   * leftmost node if the comparison result is greater than.
+   * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+   * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+   * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+   * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+   * 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: KeyOrNodeOrEntry<K, V, N> = this.root): K | undefined {
+    let current = this.ensureNode(beginRoot);
+    if (!current) return undefined;
+
+    if (this._variant === BSTVariant.STANDARD) {
+      // For BSTVariant.MIN, find the rightmost node
+      while (current.right !== undefined) {
+        current = current.right;
+      }
+    } else {
+      // For BSTVariant.MAX, find the leftmost node
+      while (current.left !== undefined) {
+        current = current.left;
+      }
+    }
+    return current.key;
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(log n)

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

@@ -41,14 +41,13 @@ export class RedBlackTreeNode<
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
 export class RedBlackTree<
-    K = any,
-    V = any,
-    N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
-    TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
+  TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>
+>
   extends BST<K, V, N, TREE>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   Sentinel: N = new RedBlackTreeNode<K, V>(NaN as K) as unknown as N;
 
   /**
@@ -133,7 +132,7 @@ export class RedBlackTree<
       } else {
         node = this.createNode(key, value, RBTNColor.RED);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
     } else {
       return;
@@ -161,16 +160,6 @@ export class RedBlackTree<
     return node instanceof RedBlackTreeNode;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof RedBlackTreeNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

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

@@ -45,14 +45,13 @@ export class TreeMultimapNode<
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export class TreeMultimap<
-    K = any,
-    V = any,
-    N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>,
-    TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>
-  >
+  K = any,
+  V = any,
+  N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>,
+  TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>
+>
   extends AVLTree<K, V, N, TREE>
-  implements IBinaryTree<K, V, N, TREE>
-{
+  implements IBinaryTree<K, V, N, TREE> {
   constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: TreeMultimapOptions<K>) {
     super([], options);
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
@@ -63,7 +62,7 @@ export class TreeMultimap<
   // TODO the _count is not accurate after nodes count modified
   get count(): number {
     let sum = 0;
-    this.subTreeTraverse(node => (sum += node.count));
+    this.dfs(node => (sum += node.count));
     return sum;
   }
 
@@ -112,7 +111,7 @@ export class TreeMultimap<
       } else {
         node = this.createNode(key, value, count);
       }
-    } else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+    } else if (!this.isNode(keyOrNodeOrEntry)) {
       node = this.createNode(keyOrNodeOrEntry, value, count);
     } else {
       return;
@@ -130,16 +129,6 @@ export class TreeMultimap<
     return keyOrNodeOrEntry instanceof TreeMultimapNode;
   }
 
-  /**
-   * The function "isNotNodeInstance" checks if a potential key is a K.
-   * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-   * data type.
-   * @returns a boolean value indicating whether the potentialKey is of type number or not.
-   */
-  override isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K {
-    return !(potentialKey instanceof TreeMultimapNode);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)

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

@@ -61,14 +61,13 @@ export abstract class AbstractEdge<E = any> {
 }
 
 export abstract class AbstractGraph<
-    V = any,
-    E = any,
-    VO extends AbstractVertex<V> = AbstractVertex<V>,
-    EO extends AbstractEdge<E> = AbstractEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends AbstractVertex<V> = AbstractVertex<V>,
+  EO extends AbstractEdge<E> = AbstractEdge<E>
+>
   extends IterableEntryBase<VertexKey, V | undefined>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   constructor() {
     super();
   }
@@ -611,14 +610,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);
 
@@ -1273,7 +1272,7 @@ export abstract class AbstractGraph<
     return mapped;
   }
 
-  protected *_getIterator(): IterableIterator<[VertexKey, V | undefined]> {
+  protected* _getIterator(): IterableIterator<[VertexKey, V | undefined]> {
     for (const vertex of this._vertexMap.values()) {
       yield [vertex.key, vertex.value];
     }

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

@@ -46,14 +46,13 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
 }
 
 export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */

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

@@ -43,14 +43,13 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
 }
 
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor initializes a new Map object to store edgeMap.
    */

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

@@ -24,24 +24,6 @@ import { isWeakKey, rangeCheck } from '../../utils';
 export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
-  protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
-    if (this.isEntry(rawElement)) {
-      // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
-      return rawElement;
-    } else {
-      throw new Error(
-        "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
-      );
-    }
-  };
-
-  get toEntryFn() {
-    return this._toEntryFn;
-  }
-
-  isEntry(rawElement: any): rawElement is [K, V] {
-    return Array.isArray(rawElement) && rawElement.length === 2;
-  }
 
   /**
    * The constructor function initializes a HashMap object with an optional initial collection and
@@ -66,12 +48,31 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     }
   }
 
+  protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
+    if (this.isEntry(rawElement)) {
+      // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+      return rawElement;
+    } else {
+      throw new Error(
+        "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+      );
+    }
+  };
+
+  get toEntryFn() {
+    return this._toEntryFn;
+  }
+
   protected _size = 0;
 
   get size(): number {
     return this._size;
   }
 
+  isEntry(rawElement: any): rawElement is [K, V] {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+
   isEmpty(): boolean {
     return this.size === 0;
   }
@@ -248,7 +249,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * The function returns an iterator that yields key-value pairs from both an object store and an
    * object map.
    */
-  protected *_getIterator(): IterableIterator<[K, V]> {
+  protected* _getIterator(): IterableIterator<[K, V]> {
     for (const node of Object.values(this._store)) {
       yield [node.key, node.value] as [K, V];
     }
@@ -347,7 +348,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   /**
    * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
    */
-  *begin() {
+  * begin() {
     let node = this._head;
     while (node !== this._sentinel) {
       yield [node.key, node.value];
@@ -359,7 +360,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
    * key and value.
    */
-  *reverseBegin() {
+  * reverseBegin() {
     let node = this._tail;
     while (node !== this._sentinel) {
       yield [node.key, node.value];
@@ -660,7 +661,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    *
    * The above function is an iterator that yields key-value pairs from a linked list.
    */
-  protected *_getIterator() {
+  protected* _getIterator() {
     let node = this._head;
     while (node !== this._sentinel) {
       yield [node.key, node.value] as [K, V];

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

@@ -391,7 +391,7 @@ export class Heap<E = any> extends IterableElementBase<E> {
     return mappedHeap;
   }
 
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     for (const element of this.elements) {
       yield element;
     }

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

@@ -808,7 +808,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     let current = this.head;
 
     while (current) {

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

@@ -741,7 +741,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return mappedList;
   }
 
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     let current = this.head;
 
     while (current) {

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

@@ -232,7 +232,7 @@ export class Deque<E> extends IterableElementBase<E> {
   /**
    * The below function is a generator that yields elements from a collection one by one.
    */
-  *begin(): Generator<E> {
+  * begin(): Generator<E> {
     let index = 0;
     while (index < this.size) {
       yield this.getAt(index);
@@ -244,7 +244,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
    * the last element.
    */
-  *reverseBegin(): Generator<E> {
+  * reverseBegin(): Generator<E> {
     let index = this.size - 1;
     while (index >= 0) {
       yield this.getAt(index);
@@ -735,7 +735,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * The above function is an implementation of the iterator protocol in TypeScript, allowing the
    * object to be iterated over using a for...of loop.
    */
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.size; ++i) {
       yield this.getAt(i);
     }

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

@@ -345,7 +345,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(n)
    */
 
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     for (const item of this.elements) {
       yield item;
     }

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

@@ -229,7 +229,7 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * Custom iterator for the Stack class.
    * @returns An iterator object.
    */
-  protected *_getIterator(): IterableIterator<E> {
+  protected* _getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.elements.length; i++) {
       yield this.elements[i];
     }

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

@@ -410,7 +410,7 @@ export class Trie extends IterableElementBase<string> {
     return newTrie;
   }
 
-  protected *_getIterator(): IterableIterator<string> {
+  protected* _getIterator(): IterableIterator<string> {
     function* _dfs(node: TrieNode, path: string): IterableIterator<string> {
       if (node.isEnd) {
         yield path;

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

@@ -2,12 +2,12 @@ export type VertexKey = string | number;
 
 export type DijkstraResult<V> =
   | {
-      distMap: Map<V, number>;
-      distPaths?: Map<V, V[]>;
-      preMap: Map<V, V | undefined>;
-      seen: Set<V>;
-      paths: V[][];
-      minDist: number;
-      minPath: V[];
-    }
+  distMap: Map<V, number>;
+  distPaths?: Map<V, V[]>;
+  preMap: Map<V, V | undefined>;
+  seen: Set<V>;
+  paths: V[][];
+  minDist: number;
+  minPath: V[];
+}
   | undefined;