data-structure-typed 1.48.5 → 1.48.7

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

@@ -113,19 +113,43 @@ export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-     * unbalanced manner, and returns an array of the inserted nodes.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-     * binary tree.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is true.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+     * balancing the tree after each addition.
+     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+     * the binary tree.
+     * @param [values] - An optional iterable of values to be associated with the keys or nodes being
+     * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
+     * order. If not provided, undefined will be assigned as the value for each key or node.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-     * tree instance.
-     * @returns The `addMany` function returns an array of `N` or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes. It has a default value of
+     * `this.iterationType`, which suggests that it is a property of the current object.
+     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
+    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

@@ -214,23 +214,32 @@ export class BST extends BinaryTree {
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
      *
-     * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-     * unbalanced manner, and returns an array of the inserted nodes.
-     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-     * binary tree.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-     * adding the nodes. The default value is true.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+     * balancing the tree after each addition.
+     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+     * the binary tree.
+     * @param [values] - An optional iterable of values to be associated with the keys or nodes being
+     * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
+     * order. If not provided, undefined will be assigned as the value for each key or node.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+     * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+     * in the order they appear in the input.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-     * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-     * tree instance.
-     * @returns The `addMany` function returns an array of `N` or `undefined` values.
+     * type of iteration to use when adding multiple keys or nodes. It has a default value of
+     * `this.iterationType`, which suggests that it is a property of the current object.
+     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries, isBalanceAdd = true, iterationType = this.iterationType) {
+    addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
+        let valuesIterator;
+        if (values) {
+            valuesIterator = values[Symbol.iterator]();
+        }
         if (!isBalanceAdd) {
             for (const kve of keysOrNodesOrEntries) {
-                const nn = this.add(kve);
+                const value = valuesIterator?.next().value;
+                const nn = this.add(kve, value);
                 inserted.push(nn);
             }
             return inserted;
@@ -244,7 +253,6 @@ export class BST extends BinaryTree {
         for (const kve of keysOrNodesOrEntries) {
             isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
         }
-        // TODO this addMany function is inefficient, it should be optimized
         let sorted = [];
         sorted = realBTNExemplars.sort((a, b) => {
             let aR, bR;
@@ -296,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.
@@ -572,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/mjs/interfaces/binary-tree.d.ts

@@ -4,6 +4,6 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
     add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
+    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }