queue-typed 1.52.1 → 1.52.3

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

@@ -922,8 +922,8 @@ class BinaryTree extends base_1.IterableEntryBase {
                     if (!this.isRealNode(node.right) || last === node.right) {
                         node = stack.pop();
                         if (this.isRealNode(node)) {
-                            const leftMinHeight = this.isRealNode(node.left) ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const rightMinHeight = this.isRealNode(node.right) ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const leftMinHeight = this.isRealNode(node.left) ? ((_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1) : -1;
+                            const rightMinHeight = this.isRealNode(node.right) ? ((_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1) : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;

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

@@ -683,8 +683,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const left = node.left ? ((_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1) : -1;
+                            const right = node.right ? ((_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1) : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));

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

@@ -60,6 +60,18 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * array is empty, it returns `undefined`.
      */
     get last(): E | undefined;
+    _autoCompactRatio: number;
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio(): number;
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v: number);
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -159,6 +171,12 @@ export declare class Queue<E = any, R = any> extends IterableElementBase<E, R, Q
      * The clear function resets the elements array and offset to their initial values.
      */
     clear(): void;
+    /**
+     * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+     * offset to zero.
+     * @returns The `compact()` method is returning a boolean value of `true`.
+     */
+    compact(): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -17,6 +17,11 @@ class Queue extends base_1.IterableElementBase {
         super(options);
         this._elements = [];
         this._offset = 0;
+        this._autoCompactRatio = 0.5;
+        if (options) {
+            const { autoCompactRatio = 0.5 } = options;
+            this._autoCompactRatio = autoCompactRatio;
+        }
         if (elements) {
             for (const el of elements) {
                 if (this.toElementFn)
@@ -77,6 +82,21 @@ class Queue extends base_1.IterableElementBase {
     get last() {
         return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
+    /**
+     * This function returns the value of the autoCompactRatio property.
+     * @returns The `autoCompactRatio` property of the object, which is a number.
+     */
+    get autoCompactRatio() {
+        return this._autoCompactRatio;
+    }
+    /**
+     * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+     * @param {number} v - The parameter `v` represents the value that will be assigned to the
+     * `_autoCompactRatio` property.
+     */
+    set autoCompactRatio(v) {
+        this._autoCompactRatio = v;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -127,12 +147,8 @@ class Queue extends base_1.IterableElementBase {
             return undefined;
         const first = this.first;
         this._offset += 1;
-        if (this.offset * 2 < this.elements.length)
-            return first;
-        // only delete dequeued elements when reaching half size
-        // to decrease latency of shifting elements.
-        this._elements = this.elements.slice(this.offset);
-        this._offset = 0;
+        if (this.offset / this.elements.length > this.autoCompactRatio)
+            this.compact();
         return first;
     }
     /**
@@ -208,6 +224,16 @@ class Queue extends base_1.IterableElementBase {
         this._elements = [];
         this._offset = 0;
     }
+    /**
+     * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+     * offset to zero.
+     * @returns The `compact()` method is returning a boolean value of `true`.
+     */
+    compact() {
+        this._elements = this.elements.slice(this.offset);
+        this._offset = 0;
+        return true;
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -418,8 +418,13 @@ class Trie extends base_1.IterableElementBase {
         if (prefix) {
             for (const c of prefix) {
                 const nodeC = startNode.children.get(c);
-                if (nodeC)
+                if (nodeC) {
                     startNode = nodeC;
+                }
+                else {
+                    // Early return if the whole prefix is not found
+                    return [];
+                }
             }
         }
         if (isAllWhenEmptyPrefix || startNode !== this.root)

package/dist/types/data-structures/queue/queue.d.ts

@@ -1,2 +1,4 @@
 import { IterableElementBaseOptions } from '../base';
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    autoCompactRatio?: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queue-typed",
-  "version": "1.52.1",
+  "version": "1.52.3",
   "description": "Queue, ArrayQueue. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -115,6 +115,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.52.1"
+    "data-structure-typed": "^1.52.3"
   }
 }

package/src/data-structures/base/iterable-element-base.ts

@@ -42,7 +42,7 @@ export abstract class IterableElementBase<E, R, C> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any number of arguments to the `_getIterator` method.
    */
-  * [Symbol.iterator](...args: any[]): IterableIterator<E> {
+  *[Symbol.iterator](...args: any[]): IterableIterator<E> {
     yield* this._getIterator(...args);
   }
 
@@ -56,7 +56,7 @@ export abstract class IterableElementBase<E, R, C> {
    *
    * The function returns an iterator that yields all the values in the object.
    */
-  * values(): IterableIterator<E> {
+  *values(): IterableIterator<E> {
     for (const item of this) {
       yield item;
     }

package/src/data-structures/base/iterable-entry-base.ts

@@ -35,7 +35,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * allows the function to accept any number of arguments as an array. In this case, the `args`
    * parameter is used to pass any additional arguments to the `_getIterator` method.
    */
-  * [Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
+  *[Symbol.iterator](...args: any[]): IterableIterator<[K, V]> {
     yield* this._getIterator(...args);
   }
 
@@ -50,7 +50,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    * The function returns an iterator that yields key-value pairs from the object, where the value can
    * be undefined.
    */
-  * entries(): IterableIterator<[K, V | undefined]> {
+  *entries(): IterableIterator<[K, V | undefined]> {
     for (const item of this) {
       yield item;
     }
@@ -66,7 +66,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the keys of a data structure.
    */
-  * keys(): IterableIterator<K> {
+  *keys(): IterableIterator<K> {
     for (const item of this) {
       yield item[0];
     }
@@ -82,7 +82,7 @@ export abstract class IterableEntryBase<K = any, V = any> {
    *
    * The function returns an iterator that yields the values of a collection.
    */
-  * values(): IterableIterator<V> {
+  *values(): IterableIterator<V> {
     for (const item of this) {
       yield item[1];
     }

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

@@ -63,20 +63,21 @@ export class AVLTreeMultiMapNode<
  * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export class AVLTreeMultiMap<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
-  TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<
-    K,
-    V,
-    R,
-    NODE,
-    AVLTreeMultiMapNested<K, V, R, NODE>
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
+    TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<
+      K,
+      V,
+      R,
+      NODE,
+      AVLTreeMultiMapNested<K, V, R, NODE>
+    >
   >
->
   extends AVLTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   /**
    * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
    * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an

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

@@ -66,14 +66,15 @@ export class AVLTreeNode<
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
  */
 export class AVLTree<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
-  TREE extends AVLTree<K, V, R, NODE, TREE> = AVLTree<K, V, R, NODE, AVLTreeNested<K, V, R, NODE>>
->
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
+    TREE extends AVLTree<K, V, R, NODE, TREE> = AVLTree<K, V, R, NODE, AVLTreeNested<K, V, R, NODE>>
+  >
   extends BST<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   /**
    * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
    * entries, or raw elements.
@@ -503,7 +504,7 @@ export class AVLTree<
       // 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-tree.ts

@@ -131,14 +131,15 @@ export class BinaryTreeNode<
  */
 
 export class BinaryTree<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
-  TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>
->
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
+    TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>
+  >
   extends IterableEntryBase<K, V | undefined>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   iterationType: IterationType = 'ITERATIVE';
 
   /**
@@ -1155,8 +1156,8 @@ export class BinaryTree<
           if (!this.isRealNode(node.right) || last === node.right) {
             node = stack.pop();
             if (this.isRealNode(node)) {
-              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
-              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
+              const leftMinHeight = this.isRealNode(node.left) ? (depths.get(node.left) ?? -1) : -1;
+              const rightMinHeight = this.isRealNode(node.right) ? (depths.get(node.right) ?? -1) : -1;
               depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
               last = node;
               node = null;
@@ -1937,7 +1938,7 @@ export class BinaryTree<
    * initially set to the root node of the tree.
    * @returns an IterableIterator<[K, V | undefined]>.
    */
-  protected* _getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
+  protected *_getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
     if (!node) return;
 
     if (this.iterationType === 'ITERATIVE') {

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

@@ -94,14 +94,15 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
 export class BST<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>,
-  TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>
->
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>,
+    TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>
+  >
   extends BinaryTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   /**
    * This is the constructor function for a Binary Search Tree class in TypeScript.
    * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
@@ -786,8 +787,8 @@ export class BST<
           if (!node.right || last === node.right) {
             node = stack.pop();
             if (node) {
-              const left = node.left ? depths.get(node.left) ?? -1 : -1;
-              const right = node.right ? depths.get(node.right) ?? -1 : -1;
+              const left = node.left ? (depths.get(node.left) ?? -1) : -1;
+              const right = node.right ? (depths.get(node.right) ?? -1) : -1;
               if (Math.abs(left - right) > 1) return false;
               depths.set(node, 1 + Math.max(left, right));
               last = node;

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

@@ -53,14 +53,15 @@ export class RedBlackTreeNode<
 }
 
 export class RedBlackTree<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
-  TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>
->
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
+    TREE extends RedBlackTree<K, V, R, NODE, TREE> = RedBlackTree<K, V, R, NODE, RedBlackTreeNested<K, V, R, NODE>>
+  >
   extends BST<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   /**
    * This is the constructor function for a Red-Black Tree data structure in TypeScript.
    * @param keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an

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

@@ -63,14 +63,15 @@ export class TreeMultiMapNode<
 }
 
 export class TreeMultiMap<
-  K = any,
-  V = any,
-  R = BTNEntry<K, V>,
-  NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>,
-  TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>
->
+    K = any,
+    V = any,
+    R = BTNEntry<K, V>,
+    NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>,
+    TREE extends TreeMultiMap<K, V, R, NODE, TREE> = TreeMultiMap<K, V, R, NODE, TreeMultiMapNested<K, V, R, NODE>>
+  >
   extends RedBlackTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE> {
+  implements IBinaryTree<K, V, R, NODE, TREE>
+{
   /**
    * The constructor function initializes a TreeMultiMap object with optional initial data.
    * @param keysOrNodesOrEntriesOrRawElements - The parameter `keysOrNodesOrEntriesOrRawElements` is an

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

@@ -61,13 +61,14 @@ 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();
   }
@@ -618,14 +619,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);
 
@@ -1069,7 +1070,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,13 +46,14 @@ 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,13 +43,14 @@ 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

@@ -322,7 +322,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];
     }
@@ -537,7 +537,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
   /**
    * 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];
@@ -549,7 +549,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * 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];
@@ -942,7 +942,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    *
    * 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

@@ -367,7 +367,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
   /**
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
-  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

@@ -803,7 +803,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   /**
    * 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

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

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

@@ -344,7 +344,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<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.at(index);
@@ -356,7 +356,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<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.at(index);
@@ -848,7 +848,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<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.at(i);
     }

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

@@ -19,6 +19,12 @@ import { SinglyLinkedList } from '../linked-list';
 export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: QueueOptions<E, R>) {
     super(options);
+
+    if (options) {
+      const { autoCompactRatio = 0.5 } = options;
+      this._autoCompactRatio = autoCompactRatio;
+    }
+
     if (elements) {
       for (const el of elements) {
         if (this.toElementFn) this.push(this.toElementFn(el as R));
@@ -89,6 +95,25 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
   }
 
+  _autoCompactRatio: number = 0.5;
+
+  /**
+   * This function returns the value of the autoCompactRatio property.
+   * @returns The `autoCompactRatio` property of the object, which is a number.
+   */
+  get autoCompactRatio(): number {
+    return this._autoCompactRatio;
+  }
+
+  /**
+   * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+   * @param {number} v - The parameter `v` represents the value that will be assigned to the
+   * `_autoCompactRatio` property.
+   */
+  set autoCompactRatio(v: number) {
+    this._autoCompactRatio = v;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -145,12 +170,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     const first = this.first;
     this._offset += 1;
 
-    if (this.offset * 2 < this.elements.length) return first;
-
-    // only delete dequeued elements when reaching half size
-    // to decrease latency of shifting elements.
-    this._elements = this.elements.slice(this.offset);
-    this._offset = 0;
+    if (this.offset / this.elements.length > this.autoCompactRatio) this.compact();
     return first;
   }
 
@@ -237,6 +257,17 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     this._offset = 0;
   }
 
+  /**
+   * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+   * offset to zero.
+   * @returns The `compact()` method is returning a boolean value of `true`.
+   */
+  compact(): boolean {
+    this._elements = this.elements.slice(this.offset);
+    this._offset = 0;
+    return true;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -317,7 +348,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    *
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     for (const item of this.elements.slice(this.offset)) {
       yield item;
     }

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

@@ -274,7 +274,7 @@ export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<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

@@ -454,7 +454,12 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
     if (prefix) {
       for (const c of prefix) {
         const nodeC = startNode.children.get(c);
-        if (nodeC) startNode = nodeC;
+        if (nodeC) {
+          startNode = nodeC;
+        } else {
+          // Early return if the whole prefix is not found
+          return [];
+        }
       }
     }
 
@@ -560,7 +565,7 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
    * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
    * trie data structure and yields all the paths to the end nodes.
    */
-  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;

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

@@ -1,6 +1,6 @@
 import { IterableElementBaseOptions } from '../base';
 
 export type DequeOptions<E, R> = {
-  bucketSize?: number,
-  maxLen?: number
+  bucketSize?: number;
+  maxLen?: number;
 } & IterableElementBaseOptions<E, R>;

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

@@ -1,3 +1,5 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+  autoCompactRatio?: number;
+};

package/src/types/utils/utils.ts

@@ -13,9 +13,9 @@ export type Comparable =
   | bigint
   | boolean
   | ({ [key in string]: any } & {
-  valueOf(): Comparable;
-})
+      valueOf(): Comparable;
+    })
   | ({ [key in string]: any } & {
-  toString(): Comparable;
-})
+      toString(): Comparable;
+    })
   | (() => Comparable);