data-structure-typed 1.48.5 → 1.48.7

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();
@@ -7648,7 +7648,7 @@ var dataStructureTyped = (() => {
     /**
      * 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:
@@ -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) {
@@ -7699,17 +7701,27 @@ var dataStructureTyped = (() => {
      * 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`.
+     * 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) {
+    addMany(nodes, values) {
       const inserted = [];
+      let valuesIterator;
+      if (values) {
+        valuesIterator = values[Symbol.iterator]();
+      }
       for (const kne of nodes) {
-        inserted.push(this.add(kne));
+        let value = void 0;
+        if (valuesIterator) {
+          const valueResult = valuesIterator.next();
+          if (!valueResult.done) {
+            value = valueResult.value;
+          }
+        }
+        inserted.push(this.add(kne, value));
       }
       return inserted;
     }
@@ -7717,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)
@@ -9236,7 +9240,7 @@ var dataStructureTyped = (() => {
     /**
      * 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:
@@ -9287,23 +9291,32 @@ var dataStructureTyped = (() => {
      * 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 ? void 0 : valuesIterator.next().value;
+          const nn = this.add(kve, value);
           inserted.push(nn);
         }
         return inserted;
@@ -9367,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.
@@ -9635,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]);
@@ -10221,7 +10242,7 @@ var dataStructureTyped = (() => {
     /**
      * 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
@@ -10680,7 +10701,7 @@ var dataStructureTyped = (() => {
     /**
      * 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
@@ -11227,7 +11248,7 @@ var dataStructureTyped = (() => {
     /**
      * 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.