min-heap-typed 1.48.6 → 1.48.8

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

@@ -132,15 +132,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      */
-    /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-     * Space Complexity: O(1)
-     *
-     * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
-     * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
-     * contain either `BTNodeExemplar` objects, keys, or entries.
-     */
-    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>): void;
+    refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): void;
     /**
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)

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

@@ -200,6 +200,9 @@ class BinaryTree extends base_1.IterableEntryBase {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
             return;
+        // TODO There are still some problems with the way duplicate nodes are handled
+        if (newNode !== null && this.has(newNode.key))
+            return undefined;
         const _bfs = (root, newNode) => {
             const queue = new queue_1.Queue([root]);
             while (queue.size > 0) {
@@ -270,17 +273,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      * Space Complexity: O(1)
      */
-    /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-     * Space Complexity: O(1)
-     *
-     * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
-     * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
-     * contain either `BTNodeExemplar` objects, keys, or entries.
-     */
-    refill(nodesOrKeysOrEntries) {
+    refill(nodesOrKeysOrEntries, values) {
         this.clear();
-        this.addMany(nodesOrKeysOrEntries);
+        this.addMany(nodesOrKeysOrEntries, values);
     }
     /**
      * Time Complexity: O(n)

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

@@ -130,6 +130,26 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
     addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    /**
+     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     */
+    /**
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * Space Complexity: O(1) - Constant space is used.
+     *
+     * 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`).
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed. It can have one of the following values:
+     * @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?: BSTNodeKeyOrNode<K, N>): K | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.

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

@@ -301,31 +301,43 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    // /**
-    //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-    //  * Space Complexity: O(n) - Additional space is required for the sorted array.
-    //  */
-    //
-    // /**
-    //  * Time Complexity: O(log n) - Average case for a balanced tree.
-    //  * Space Complexity: O(1) - Constant space is used.
-    //  *
-    //  * 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`).
-    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-    //  * be performed. It can have one of the following values:
-    //  * @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: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
-    //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-    //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
-    //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-    // }
+    /**
+     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     */
+    /**
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * Space Complexity: O(1) - Constant space is used.
+     *
+     * 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`).
+     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+     * be performed. It can have one of the following values:
+     * @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 = this.root) {
+        let current = this.ensureNode(beginRoot);
+        if (!current)
+            return undefined;
+        if (this._variant === types_1.BSTVariant.MIN) {
+            // 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) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -577,7 +589,6 @@ class BST extends binary_tree_1.BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        debugger;
                         this.add([midNode.key, midNode.value]);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -89,11 +89,11 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
      * list is empty, it returns undefined.
      */
-    popLast(): E | undefined;
+    pollLast(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -115,11 +115,11 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    popFirst(): E | undefined;
+    pollFirst(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -142,11 +142,11 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
      * list is empty, it returns undefined.
      */
-    popLast() {
+    pollLast() {
         return this.pop();
     }
     /**
@@ -184,11 +184,11 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
      * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
      * list.
      */
-    popFirst() {
+    pollFirst() {
         return this.shift();
     }
     /**

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -90,12 +90,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
      * the linked list is empty, it returns `undefined`.
      */
-    popLast(): E | undefined;
+    pollLast(): E | undefined;
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
      * Space Complexity: O(1) - Constant space.
@@ -116,10 +116,10 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * The `pollFirst()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
-    popFirst(): E | undefined;
+    pollFirst(): E | undefined;
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
      * Space Complexity: O(1) - Constant space.

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -144,12 +144,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+     * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
      * the linked list is empty, it returns `undefined`.
      */
-    popLast() {
+    pollLast() {
         return this.pop();
     }
     /**
@@ -179,10 +179,10 @@ class SinglyLinkedList extends base_1.IterableElementBase {
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `popFirst()` function removes and returns the value of the first node in a linked list.
+     * The `pollFirst()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
-    popFirst() {
+    pollFirst() {
         return this.shift();
     }
     /**

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

@@ -67,10 +67,10 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * Time Complexity: O(1) - Removes the last element.
      * Space Complexity: O(1) - Operates in-place.
      *
-     * The function "popLast" removes and returns the last element of an array.
+     * The function "pollLast" removes and returns the last element of an array.
      * @returns The last element of the array is being returned.
      */
-    popLast(): E | undefined;
+    pollLast(): E | undefined;
     /**
      * Time Complexity: O(1).
      * Space Complexity: O(n) - Due to potential resizing.
@@ -84,11 +84,11 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * Time Complexity: O(1) - Removes the first element.
      * Space Complexity: O(1) - In-place operation.
      *
-     * The function "popFirst" removes and returns the first element of an array.
-     * @returns The method `popFirst()` is returning the first element of the array after removing it
+     * The function "pollFirst" removes and returns the first element of an array.
+     * @returns The method `pollFirst()` is returning the first element of the array after removing it
      * from the beginning. If the array is empty, it will return `undefined`.
      */
-    popFirst(): E | undefined;
+    pollFirst(): E | undefined;
     /**
      * The clear() function resets the state of the object by initializing all variables to their default
      * values.
@@ -488,10 +488,10 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `popFirst()` removes and returns the first element in a data structure.
+     * The function `pollFirst()` removes and returns the first element in a data structure.
      * @returns The element of the first element in the data structure.
      */
-    popFirst(): E | undefined;
+    pollFirst(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -512,10 +512,10 @@ export declare class ObjectDeque<E = number> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popLast()` function removes and returns the last element in a data structure.
+     * The `pollLast()` function removes and returns the last element in a data structure.
      * @returns The element that was removed from the data structure.
      */
-    popLast(): E | undefined;
+    pollLast(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -111,10 +111,10 @@ class Deque extends base_1.IterableElementBase {
      * Time Complexity: O(1) - Removes the last element.
      * Space Complexity: O(1) - Operates in-place.
      *
-     * The function "popLast" removes and returns the last element of an array.
+     * The function "pollLast" removes and returns the last element of an array.
      * @returns The last element of the array is being returned.
      */
-    popLast() {
+    pollLast() {
         return this.pop();
     }
     /**
@@ -132,11 +132,11 @@ class Deque extends base_1.IterableElementBase {
      * Time Complexity: O(1) - Removes the first element.
      * Space Complexity: O(1) - In-place operation.
      *
-     * The function "popFirst" removes and returns the first element of an array.
-     * @returns The method `popFirst()` is returning the first element of the array after removing it
+     * The function "pollFirst" removes and returns the first element of an array.
+     * @returns The method `pollFirst()` is returning the first element of the array after removing it
      * from the beginning. If the array is empty, it will return `undefined`.
      */
-    popFirst() {
+    pollFirst() {
         return this.shift();
     }
     /**
@@ -875,10 +875,10 @@ class ObjectDeque {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `popFirst()` removes and returns the first element in a data structure.
+     * The function `pollFirst()` removes and returns the first element in a data structure.
      * @returns The element of the first element in the data structure.
      */
-    popFirst() {
+    pollFirst() {
         if (!this.size)
             return;
         const element = this.getFirst();
@@ -910,10 +910,10 @@ class ObjectDeque {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `popLast()` function removes and returns the last element in a data structure.
+     * The `pollLast()` function removes and returns the last element in a data structure.
      * @returns The element that was removed from the data structure.
      */
-    popLast() {
+    pollLast() {
         if (!this.size)
             return;
         const element = this.getLast();

package/package.json

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

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

@@ -248,6 +248,9 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
     if (newNode === undefined) return;
 
+    // TODO There are still some problems with the way duplicate nodes are handled
+    if (newNode !== null && this.has(newNode.key)) return undefined;
+
     const _bfs = (root: N, newNode: N | null): N | undefined | null => {
       const queue = new Queue<N>([root]);
       while (queue.size > 0) {
@@ -325,17 +328,9 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Space Complexity: O(1)
    */
 
-  /**
-   * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
-   * Space Complexity: O(1)
-   *
-   * The `refill` function clears the current collection and adds new nodes, keys, or entries to it.
-   * @param nodesOrKeysOrEntries - The parameter `nodesOrKeysOrEntries` is an iterable object that can
-   * contain either `BTNodeExemplar` objects, keys, or entries.
-   */
-  refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>): void {
+  refill(nodesOrKeysOrEntries: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): void {
     this.clear();
-    this.addMany(nodesOrKeysOrEntries);
+    this.addMany(nodesOrKeysOrEntries, values);
   }
 
   /**

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

@@ -359,31 +359,44 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   }
 
 
-  // /**
-  //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-  //  * Space Complexity: O(n) - Additional space is required for the sorted array.
-  //  */
-  //
-  // /**
-  //  * Time Complexity: O(log n) - Average case for a balanced tree.
-  //  * Space Complexity: O(1) - Constant space is used.
-  //  *
-  //  * 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`).
-  //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-  //  * be performed. It can have one of the following values:
-  //  * @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: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
-  //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-  //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
-  //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-  // }
+  /**
+   * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+   * Space Complexity: O(n) - Additional space is required for the sorted array.
+   */
+
+  /**
+   * Time Complexity: O(log n) - Average case for a balanced tree.
+   * Space Complexity: O(1) - Constant space is used.
+   *
+   * 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`).
+   * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+   * be performed. It can have one of the following values:
+   * @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: BSTNodeKeyOrNode<K, N> = this.root): K | undefined {
+    let current = this.ensureNode(beginRoot);
+    if (!current) return undefined;
+
+    if (this._variant === BSTVariant.MIN) {
+      // 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) - Average case for a balanced tree.
@@ -636,7 +649,6 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            debugger;
             this.add([midNode.key, midNode.value]);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);

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

@@ -625,7 +625,7 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected* _getIterator() {
     let node = this._head;
     while (node !== this._sentinel) {
-      yield <[K, V]>[node.key, node.value];
+      yield [node.key, node.value] as [K, V];
       node = node.next;
     }
   }

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

@@ -162,11 +162,11 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
+   * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
    * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
    * list is empty, it returns undefined.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -206,11 +206,11 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
+   * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
    * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
    * list.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 

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

@@ -164,12 +164,12 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
    * Space Complexity: O(1) - Constant space.
    *
-   * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
+   * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
    * pointers accordingly.
    * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
    * the linked list is empty, it returns `undefined`.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -202,10 +202,10 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
    * Space Complexity: O(1) - Constant space.
    *
-   * The `popFirst()` function removes and returns the value of the first node in a linked list.
+   * The `pollFirst()` function removes and returns the value of the first node in a linked list.
    * @returns The value of the node that is being removed from the beginning of the linked list.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 

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

@@ -120,10 +120,10 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Removes the last element.
    * Space Complexity: O(1) - Operates in-place.
    *
-   * The function "popLast" removes and returns the last element of an array.
+   * The function "pollLast" removes and returns the last element of an array.
    * @returns The last element of the array is being returned.
    */
-  popLast(): E | undefined {
+  pollLast(): E | undefined {
     return this.pop();
   }
 
@@ -143,11 +143,11 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(1) - Removes the first element.
    * Space Complexity: O(1) - In-place operation.
    *
-   * The function "popFirst" removes and returns the first element of an array.
-   * @returns The method `popFirst()` is returning the first element of the array after removing it
+   * The function "pollFirst" removes and returns the first element of an array.
+   * @returns The method `pollFirst()` is returning the first element of the array after removing it
    * from the beginning. If the array is empty, it will return `undefined`.
    */
-  popFirst(): E | undefined {
+  pollFirst(): E | undefined {
     return this.shift();
   }
 
@@ -947,10 +947,10 @@ export class ObjectDeque<E = number> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `popFirst()` removes and returns the first element in a data structure.
+   * The function `pollFirst()` removes and returns the first element in a data structure.
    * @returns The element of the first element in the data structure.
    */
-  popFirst() {
+  pollFirst() {
     if (!this.size) return;
     const element = this.getFirst();
     delete this.nodes[this.first];
@@ -984,10 +984,10 @@ export class ObjectDeque<E = number> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `popLast()` function removes and returns the last element in a data structure.
+   * The `pollLast()` function removes and returns the last element in a data structure.
    * @returns The element that was removed from the data structure.
    */
-  popLast() {
+  pollLast() {
     if (!this.size) return;
     const element = this.getLast();
     delete this.nodes[this.last];
@@ -1039,4 +1039,4 @@ export class ObjectDeque<E = number> {
   isEmpty() {
     return this.size <= 0;
   }
-}
+}

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

@@ -378,4 +378,4 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   peek(): E | undefined {
     return this.getFirst();
   }
-}
+}

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

@@ -7,4 +7,4 @@ export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNo
 
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type RBTreeOptions<K> = BSTOptions<K> & {};
+export type RBTreeOptions<K> = BSTOptions<K> & {};

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

@@ -1,3 +1,3 @@
 import { Comparator } from "../../common";
 
-export type HeapOptions<T> = { comparator: Comparator<T> }
+export type HeapOptions<T> = { comparator: Comparator<T> }

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

@@ -1,3 +1,3 @@
 import { HeapOptions } from "../heap";
 
-export type PriorityQueueOptions<T> = HeapOptions<T> & {}
+export type PriorityQueueOptions<T> = HeapOptions<T> & {}