data-structure-typed 1.48.6 → 1.48.8

package/dist/mjs/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/mjs/data-structures/binary-tree/bst.js

@@ -304,31 +304,43 @@ export class BST extends 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 === 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.
@@ -580,7 +592,6 @@ export class BST extends 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/mjs/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/mjs/data-structures/linked-list/doubly-linked-list.js

@@ -144,11 +144,11 @@ export class DoublyLinkedList extends 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();
     }
     /**
@@ -186,11 +186,11 @@ export class DoublyLinkedList extends 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/mjs/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/mjs/data-structures/linked-list/singly-linked-list.js

@@ -145,12 +145,12 @@ export class SinglyLinkedList extends 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();
     }
     /**
@@ -180,10 +180,10 @@ export class SinglyLinkedList extends 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/mjs/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/mjs/data-structures/queue/deque.js

@@ -109,10 +109,10 @@ export class Deque extends 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();
     }
     /**
@@ -130,11 +130,11 @@ export class Deque extends 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();
     }
     /**
@@ -872,10 +872,10 @@ export 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();
@@ -907,10 +907,10 @@ export 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/dist/umd/data-structure-typed.js

@@ -1539,12 +1539,12 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -1574,10 +1574,10 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -2212,11 +2212,11 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -2253,11 +2253,11 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -3692,10 +3692,10 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -3713,11 +3713,11 @@ var dataStructureTyped = (() => {
      * 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();
     }
     /**
@@ -4452,10 +4452,10 @@ var dataStructureTyped = (() => {
      * 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();
@@ -4487,10 +4487,10 @@ var dataStructureTyped = (() => {
      * 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();
@@ -7660,6 +7660,8 @@ var dataStructureTyped = (() => {
       const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
       if (newNode === void 0)
         return;
+      if (newNode !== null && this.has(newNode.key))
+        return void 0;
       const _bfs = (root, newNode2) => {
         const queue = new Queue([root]);
         while (queue.size > 0) {
@@ -7727,17 +7729,9 @@ var dataStructureTyped = (() => {
      * 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)
@@ -9386,31 +9380,40 @@ var dataStructureTyped = (() => {
       }
       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 void 0;
+      if (this._variant === "MIN" /* MIN */) {
+        while (current.right !== void 0) {
+          current = current.right;
+        }
+      } else {
+        while (current.left !== void 0) {
+          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.
@@ -9654,7 +9657,6 @@ var dataStructureTyped = (() => {
             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]);