queue-typed 1.48.5 → 1.48.6

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

@@ -121,14 +121,13 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
-     * current instance, and returns an array of the inserted nodes.
-     * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-     * `BTNodeExemplar<K, V,N>` objects.
-     * @returns The function `addMany` returns an array of values, where each value is either of type
-     * `N`, `null`, or `undefined`.
-     */
-    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
+     * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+     * adds each node with its corresponding value to the data structure.
+     * @param nodes - An iterable collection of BTNodeExemplar objects.
+     * @param [values] - An optional iterable of values that will be assigned to each node being added.
+     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     */
+    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
     /**
      * 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

@@ -241,18 +241,28 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
-     * current instance, and returns an array of the inserted nodes.
-     * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-     * `BTNodeExemplar<K, V,N>` objects.
-     * @returns The function `addMany` returns an array of values, where each value is either of type
-     * `N`, `null`, or `undefined`.
-     */
-    addMany(nodes) {
+     * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+     * adds each node with its corresponding value to the data structure.
+     * @param nodes - An iterable collection of BTNodeExemplar objects.
+     * @param [values] - An optional iterable of values that will be assigned to each node being added.
+     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     */
+    addMany(nodes, values) {
         // TODO not sure addMany not be run multi times
         const inserted = [];
+        let valuesIterator;
+        if (values) {
+            valuesIterator = values[Symbol.iterator]();
+        }
         for (const kne of nodes) {
-            inserted.push(this.add(kne));
+            let value = undefined;
+            if (valuesIterator) {
+                const valueResult = valuesIterator.next();
+                if (!valueResult.done) {
+                    value = valueResult.value;
+                }
+            }
+            inserted.push(this.add(kne, value));
         }
         return inserted;
     }

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

@@ -113,19 +113,23 @@ 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(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.

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

@@ -211,23 +211,32 @@ class BST extends binary_tree_1.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 === null || valuesIterator === void 0 ? void 0 : valuesIterator.next().value;
+                const nn = this.add(kve, value);
                 inserted.push(nn);
             }
             return inserted;
@@ -241,7 +250,6 @@ class BST extends binary_tree_1.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;

package/dist/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>[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "queue-typed",
-  "version": "1.48.5",
+  "version": "1.48.6",
   "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.48.5"
+    "data-structure-typed": "^1.48.6"
   }
 }

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

@@ -99,7 +99,7 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and balances the tree after inserting
    * a new node.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

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

@@ -235,7 +235,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
    * existing node with the same key.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
@@ -288,22 +288,38 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    *
-   * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
-   * current instance, and returns an array of the inserted nodes.
-   * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-   * `BTNodeExemplar<K, V,N>` objects.
-   * @returns The function `addMany` returns an array of values, where each value is either of type
-   * `N`, `null`, or `undefined`.
-   */
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[] {
+   * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+   * adds each node with its corresponding value to the data structure.
+   * @param nodes - An iterable collection of BTNodeExemplar objects.
+   * @param [values] - An optional iterable of values that will be assigned to each node being added.
+   * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+   */
+  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[] {
     // TODO not sure addMany not be run multi times
     const inserted: (N | null | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+    if (values) {
+      valuesIterator = values[Symbol.iterator]();
+    }
+
     for (const kne of nodes) {
-      inserted.push(this.add(kne));
+      let value: V | undefined | null = undefined;
+
+      if (valuesIterator) {
+        const valueResult = valuesIterator.next();
+        if (!valueResult.done) {
+          value = valueResult.value;
+        }
+      }
+
+      inserted.push(this.add(kne, value));
     }
+
     return inserted;
   }
 
+
   /**
    * 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/src/data-structures/binary-tree/bst.ts

@@ -192,7 +192,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
    * Space Complexity: O(1) - Constant space is used.
-   * 
+   *
    * The `add` function adds a new node to a binary tree, updating the value if the key already exists
    * or inserting a new node if the key is unique.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
@@ -256,31 +256,45 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * 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.
    */
   override addMany(
     keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>,
+    values?: Iterable<V | undefined>,
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | undefined)[] {
-    const inserted: (N | undefined)[] = []
+    const inserted: (N | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+
+    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;
     }
+
     const realBTNExemplars: BTNodePureExemplar<K, V, N>[] = [];
 
     const isRealBTNExemplar = (kve: BTNodeExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
@@ -292,22 +306,20 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
     }
 
-    // TODO this addMany function is inefficient, it should be optimized
     let sorted: BTNodePureExemplar<K, V, N>[] = [];
 
     sorted = realBTNExemplars.sort((a, b) => {
       let aR: number, bR: number;
-      if (this.isEntry(a)) aR = this.extractor(a[0])
-      else if (this.isRealNode(a)) aR = this.extractor(a.key)
+      if (this.isEntry(a)) aR = this.extractor(a[0]);
+      else if (this.isRealNode(a)) aR = this.extractor(a.key);
       else aR = this.extractor(a);
 
-      if (this.isEntry(b)) bR = this.extractor(b[0])
-      else if (this.isRealNode(b)) bR = this.extractor(b.key)
+      if (this.isEntry(b)) bR = this.extractor(b[0]);
+      else if (this.isRealNode(b)) bR = this.extractor(b.key);
       else bR = this.extractor(b);
 
       return aR - bR;
-    })
-
+    });
 
     const _dfs = (arr: BTNodePureExemplar<K, V, N>[]) => {
       if (arr.length === 0) return;
@@ -318,6 +330,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
     };
+
     const _iterate = () => {
       const n = sorted.length;
       const stack: [[number, number]] = [[0, n - 1]];
@@ -335,6 +348,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
         }
       }
     };
+
     if (iterationType === IterationType.RECURSIVE) {
       _dfs(sorted);
     } else {
@@ -344,6 +358,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     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.

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

@@ -153,7 +153,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary search tree and performs necessary rotations and
    * color changes to maintain the red-black tree properties.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

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

@@ -126,7 +126,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and adds a new node to the tree.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
    * entry. It represents the key, node, or entry that you want to add to the binary tree.

package/src/interfaces/binary-tree.ts

@@ -15,7 +15,7 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   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>[];
 }